<!DOCTYPE html>
<html>
<head>
  <meta charset="utf-8">
  
  <title>Java编程思想笔记五 | 净土</title>
  <meta name="viewport" content="width=device-width, initial-scale=1, maximum-scale=1">
  <meta name="description" content="thinking in java; java编程思想; 数组; 容器深入研究">
<meta property="og:type" content="article">
<meta property="og:title" content="Java编程思想笔记五">
<meta property="og:url" content="http://howiefh.github.io/2014/10/30/thinking-in-java-note-5/index.html">
<meta property="og:site_name" content="净土">
<meta property="og:description" content="thinking in java; java编程思想; 数组; 容器深入研究">
<meta property="og:image" content="http://fh-1.qiniudn.com/full_container_taxonomy.png">
<meta property="og:updated_time" content="2015-04-05T04:22:16.000Z">
<meta name="twitter:card" content="summary">
<meta name="twitter:title" content="Java编程思想笔记五">
<meta name="twitter:description" content="thinking in java; java编程思想; 数组; 容器深入研究">
  
    <link rel="alternative" href="/atom.xml" title="净土" type="application/atom+xml">
  
  
    <link rel="icon" href="/favicon.ico">
  
  <link href="http://fonts.useso.com/css?family=Source+Code+Pro" rel="stylesheet" type="text/css">
  <link rel="stylesheet" href="/css/style.css" type="text/css">
  
<script type="text/javascript">
(function(i,s,o,g,r,a,m){i['GoogleAnalyticsObject']=r;i[r]=i[r]||function(){
(i[r].q=i[r].q||[]).push(arguments)},i[r].l=1*new Date();a=s.createElement(o),
m=s.getElementsByTagName(o)[0];a.async=1;a.src=g;m.parentNode.insertBefore(a,m)
})(window,document,'script','//www.google-analytics.com/analytics.js','ga');

ga('create', 'UA-40492061-1', 'auto');
ga('send', 'pageview');

</script>


  
<script>
var _hmt = _hmt || [];
(function() {
  var hm = document.createElement("script");
  hm.src = "//hm.baidu.com/hm.js?56d2899c5e919fbf4a7b00de5d1c31dd";
  var s = document.getElementsByTagName("script")[0]; 
  s.parentNode.insertBefore(hm, s);
})();
</script>


</head>

<body>
  <div id="container">
    <div id="wrap">
      <header id="header">
  <div id="banner"></div>
  <div id="header-outer" class="outer">
    <div id="header-title" class="inner">
      <h1 id="logo-wrap">
        <a href="/" id="logo">净土</a>
      </h1>
      
        <h2 id="subtitle-wrap">
          <a href="/" id="subtitle">乐不在外而在心，心以为乐，则是境皆乐；心以为苦，则无境不苦。</a>
        </h2>
      
    </div>
    <div id="header-inner" class="inner">
      <nav id="main-nav">
        <a id="main-nav-toggle" class="nav-icon"></a>
        
          <a class="main-nav-link" href="/">Home</a>
        
          <a class="main-nav-link" href="/archives">Archives</a>
        
      </nav>
      <nav id="sub-nav">
        
          <a id="nav-github-link" class="nav-icon" href="https://github.com/howiefh" title="Github" target="_blank"></a>
        
        
          <a id="nav-rss-link" class="nav-icon" href="/atom.xml" title="RSS Feed" target="_blank"></a>
        
        <a id="nav-search-btn" class="nav-icon" title="Search"></a>
      </nav>
      <div id="search-form-wrap">
        <form action="//google.com/search" method="get" accept-charset="UTF-8" class="search-form"><input type="search" name="q" results="0" class="search-form-input" placeholder="Search"><button type="submit" class="search-form-submit">&#xF002;</button><input type="hidden" name="sitesearch" value="http://howiefh.github.io"></form>
      </div>
    </div>
  </div>
</header>

      <div class="outer">
        <section id="main"><article id="post-thinking-in-java-note-5" class="article article-type-post" itemscope itemprop="blogPost">
  <div class="article-meta">
    
<a href="/2014/10/30/thinking-in-java-note-5/" class="article-date">
  <time datetime="2014-10-30T03:54:53.000Z" itemprop="datePublished">2014-10-30</time>
</a>


    
  <div class="article-category">
    <a class="article-category-link" href="/categories/Java/">Java</a>
  </div>

  </div>
  <div class="article-inner">
    
    
      <header class="article-header">
        
  
    <h1 class="article-title" itemprop="name">
      Java编程思想笔记五
    </h1>
  

      </header>
    
    <div class="article-entry" itemprop="articleBody">
      
		
		<div id="toc" class="toc-article">
			<h2 class="toc-title"><span>Contents</span></h2>
		
			<ol class="toc"><li class="toc-item toc-level-2"><a class="toc-link" href="#数组"><span class="toc-number">1.</span> <span class="toc-text">数组</span></a><ol class="toc-child"><li class="toc-item toc-level-3"><a class="toc-link" href="#数组为什么特殊"><span class="toc-number">1.1.</span> <span class="toc-text">数组为什么特殊</span></a></li><li class="toc-item toc-level-3"><a class="toc-link" href="#数组是第一级对象"><span class="toc-number">1.2.</span> <span class="toc-text">数组是第一级对象</span></a></li><li class="toc-item toc-level-3"><a class="toc-link" href="#返回一个数组"><span class="toc-number">1.3.</span> <span class="toc-text">返回一个数组</span></a></li><li class="toc-item toc-level-3"><a class="toc-link" href="#多维数组"><span class="toc-number">1.4.</span> <span class="toc-text">多维数组</span></a></li><li class="toc-item toc-level-3"><a class="toc-link" href="#数组与泛型"><span class="toc-number">1.5.</span> <span class="toc-text">数组与泛型</span></a></li><li class="toc-item toc-level-3"><a class="toc-link" href="#创建测试数据"><span class="toc-number">1.6.</span> <span class="toc-text">创建测试数据</span></a><ol class="toc-child"><li class="toc-item toc-level-4"><a class="toc-link" href="#Arrays-fill()"><span class="toc-number">1.6.1.</span> <span class="toc-text">Arrays.fill()</span></a></li><li class="toc-item toc-level-4"><a class="toc-link" href="#数据生成器"><span class="toc-number">1.6.2.</span> <span class="toc-text">数据生成器</span></a></li></ol></li><li class="toc-item toc-level-3"><a class="toc-link" href="#Arrays实用功能"><span class="toc-number">1.7.</span> <span class="toc-text">Arrays实用功能</span></a><ol class="toc-child"><li class="toc-item toc-level-4"><a class="toc-link" href="#复制数组"><span class="toc-number">1.7.1.</span> <span class="toc-text">复制数组</span></a></li><li class="toc-item toc-level-4"><a class="toc-link" href="#数组的比较"><span class="toc-number">1.7.2.</span> <span class="toc-text">数组的比较</span></a></li><li class="toc-item toc-level-4"><a class="toc-link" href="#数组元素的比较"><span class="toc-number">1.7.3.</span> <span class="toc-text">数组元素的比较</span></a></li><li class="toc-item toc-level-4"><a class="toc-link" href="#数组排序"><span class="toc-number">1.7.4.</span> <span class="toc-text">数组排序</span></a></li><li class="toc-item toc-level-4"><a class="toc-link" href="#在已排序的数组中查找"><span class="toc-number">1.7.5.</span> <span class="toc-text">在已排序的数组中查找</span></a></li></ol></li></ol></li><li class="toc-item toc-level-2"><a class="toc-link" href="#容器深入研究"><span class="toc-number">2.</span> <span class="toc-text">容器深入研究</span></a><ol class="toc-child"><li class="toc-item toc-level-3"><a class="toc-link" href="#完整的容器分类法"><span class="toc-number">2.1.</span> <span class="toc-text">完整的容器分类法</span></a></li><li class="toc-item toc-level-3"><a class="toc-link" href="#填充容器"><span class="toc-number">2.2.</span> <span class="toc-text">填充容器</span></a><ol class="toc-child"><li class="toc-item toc-level-4"><a class="toc-link" href="#一种Generator解决方案"><span class="toc-number">2.2.1.</span> <span class="toc-text">一种Generator解决方案</span></a></li><li class="toc-item toc-level-4"><a class="toc-link" href="#Map生成器"><span class="toc-number">2.2.2.</span> <span class="toc-text">Map生成器</span></a></li><li class="toc-item toc-level-4"><a class="toc-link" href="#使用Abstract类"><span class="toc-number">2.2.3.</span> <span class="toc-text">使用Abstract类</span></a></li></ol></li><li class="toc-item toc-level-3"><a class="toc-link" href="#Collection的功能方法"><span class="toc-number">2.3.</span> <span class="toc-text">Collection的功能方法</span></a></li><li class="toc-item toc-level-3"><a class="toc-link" href="#可选操作"><span class="toc-number">2.4.</span> <span class="toc-text">可选操作</span></a><ol class="toc-child"><li class="toc-item toc-level-4"><a class="toc-link" href="#未获支持的操作"><span class="toc-number">2.4.1.</span> <span class="toc-text">未获支持的操作</span></a></li></ol></li><li class="toc-item toc-level-3"><a class="toc-link" href="#List的功能方法"><span class="toc-number">2.5.</span> <span class="toc-text">List的功能方法</span></a></li><li class="toc-item toc-level-3"><a class="toc-link" href="#Set和存储顺序"><span class="toc-number">2.6.</span> <span class="toc-text">Set和存储顺序</span></a><ol class="toc-child"><li class="toc-item toc-level-4"><a class="toc-link" href="#SortedSet"><span class="toc-number">2.6.1.</span> <span class="toc-text">SortedSet</span></a></li></ol></li><li class="toc-item toc-level-3"><a class="toc-link" href="#队列"><span class="toc-number">2.7.</span> <span class="toc-text">队列</span></a><ol class="toc-child"><li class="toc-item toc-level-4"><a class="toc-link" href="#双向队列"><span class="toc-number">2.7.1.</span> <span class="toc-text">双向队列</span></a></li></ol></li><li class="toc-item toc-level-3"><a class="toc-link" href="#理解Map"><span class="toc-number">2.8.</span> <span class="toc-text">理解Map</span></a><ol class="toc-child"><li class="toc-item toc-level-4"><a class="toc-link" href="#性能"><span class="toc-number">2.8.1.</span> <span class="toc-text">性能</span></a></li><li class="toc-item toc-level-4"><a class="toc-link" href="#SortedMap"><span class="toc-number">2.8.2.</span> <span class="toc-text">SortedMap</span></a></li><li class="toc-item toc-level-4"><a class="toc-link" href="#LinkedHashMap"><span class="toc-number">2.8.3.</span> <span class="toc-text">LinkedHashMap</span></a></li></ol></li><li class="toc-item toc-level-3"><a class="toc-link" href="#散列与散列码"><span class="toc-number">2.9.</span> <span class="toc-text">散列与散列码</span></a><ol class="toc-child"><li class="toc-item toc-level-4"><a class="toc-link" href="#正确的equals()方法必须满足下列5个条件："><span class="toc-number">2.9.1.</span> <span class="toc-text">正确的equals()方法必须满足下列5个条件：</span></a></li><li class="toc-item toc-level-4"><a class="toc-link" href="#理解hashCode()"><span class="toc-number">2.9.2.</span> <span class="toc-text">理解hashCode()</span></a></li><li class="toc-item toc-level-4"><a class="toc-link" href="#为速度而散列"><span class="toc-number">2.9.3.</span> <span class="toc-text">为速度而散列</span></a></li><li class="toc-item toc-level-4"><a class="toc-link" href="#覆盖hashCode()"><span class="toc-number">2.9.4.</span> <span class="toc-text">覆盖hashCode()</span></a></li></ol></li><li class="toc-item toc-level-3"><a class="toc-link" href="#选择接口的不同实现"><span class="toc-number">2.10.</span> <span class="toc-text">选择接口的不同实现</span></a></li><li class="toc-item toc-level-3"><a class="toc-link" href="#性能测试框架"><span class="toc-number">2.11.</span> <span class="toc-text">性能测试框架</span></a><ol class="toc-child"><li class="toc-item toc-level-4"><a class="toc-link" href="#对List的选择"><span class="toc-number">2.11.1.</span> <span class="toc-text">对List的选择</span></a></li><li class="toc-item toc-level-4"><a class="toc-link" href="#微基准测试的危险"><span class="toc-number">2.11.2.</span> <span class="toc-text">微基准测试的危险</span></a></li><li class="toc-item toc-level-4"><a class="toc-link" href="#对Set的选择"><span class="toc-number">2.11.3.</span> <span class="toc-text">对Set的选择</span></a></li><li class="toc-item toc-level-4"><a class="toc-link" href="#对Map的选择"><span class="toc-number">2.11.4.</span> <span class="toc-text">对Map的选择</span></a></li></ol></li><li class="toc-item toc-level-3"><a class="toc-link" href="#实用方法(java-util-Collections)"><span class="toc-number">2.12.</span> <span class="toc-text">实用方法(java.util.Collections)</span></a><ol class="toc-child"><li class="toc-item toc-level-4"><a class="toc-link" href="#设定Collection或Map为不可修改"><span class="toc-number">2.12.1.</span> <span class="toc-text">设定Collection或Map为不可修改</span></a></li><li class="toc-item toc-level-4"><a class="toc-link" href="#Collection或Map的同步控制"><span class="toc-number">2.12.2.</span> <span class="toc-text">Collection或Map的同步控制</span></a></li></ol></li><li class="toc-item toc-level-3"><a class="toc-link" href="#持有引用"><span class="toc-number">2.13.</span> <span class="toc-text">持有引用</span></a><ol class="toc-child"><li class="toc-item toc-level-4"><a class="toc-link" href="#WeakHashMap"><span class="toc-number">2.13.1.</span> <span class="toc-text">WeakHashMap</span></a></li></ol></li><li class="toc-item toc-level-3"><a class="toc-link" href="#Java_1-0/1-1的容器"><span class="toc-number">2.14.</span> <span class="toc-text">Java 1.0/1.1的容器</span></a><ol class="toc-child"><li class="toc-item toc-level-4"><a class="toc-link" href="#BitSet"><span class="toc-number">2.14.1.</span> <span class="toc-text">BitSet</span></a></li></ol></li></ol></li></ol>
		
		</div>
		
        <h2 id="数组">数组</h2><h3 id="数组为什么特殊">数组为什么特殊</h3><p>数组和其它容器之间的区别有三方面：效率、编译期类型检查和保存基本类型的能力，但是由于有了泛型容器和自动包装机制，现在最主要的区别就是效率。ArrayList效率低很多。<br><a id="more"></a></p>
<h3 id="数组是第一级对象">数组是第一级对象</h3><p>数组标示符其实是一个引用，指向堆中创建的一个真实对象，可以作为数组初始化语法的一部分隐式的创建此对象，或者用new表达式显示的创建。只读成员length是唯一一个可以访问的字段，通过length你知道的仅仅是数组的大小，而不是里面元素的个数。[]是访问数组对象的唯一方式。</p>
<p>对象数组和基本类型数组在使用上几乎是相同的，唯一区别是对象数组保存的是引用，基本类型数组直接保存基本类型的值。</p>
<p>新生成一个数组，其中所有引用被自动初始化为null，基本类型被初始化为0（boolean是false）。</p>
<p>初始化为指向一个BerylliumSphere引用的数组并给每个元素赋值<br><figure class="highlight swift"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br></pre></td><td class="code"><pre><span class="line"><span class="type">BerylliumSphere</span>[] <span class="built_in">c</span> = <span class="keyword">new</span> <span class="type">BerylliumSphere</span>[<span class="number">4</span>];</span><br><span class="line"><span class="keyword">for</span>(int i = <span class="number">0</span>; i &lt; <span class="built_in">c</span>.length; i++)</span><br><span class="line">    <span class="keyword">if</span>(<span class="built_in">c</span>[i] == null) <span class="comment">// Can test for null reference</span></span><br><span class="line">        <span class="built_in">c</span>[i] = <span class="keyword">new</span> <span class="type">BerylliumSphere</span>();</span><br></pre></td></tr></table></figure></p>
<p>聚集初始化语法创建数组对象：隐式的使用new语法在堆中创建(Aggregate initialization):<br><figure class="highlight ocaml"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br></pre></td><td class="code"><pre><span class="line"><span class="type">BerylliumSphere</span><span class="literal">[]</span> d = &#123; <span class="keyword">new</span> <span class="type">BerylliumSphere</span><span class="literal">()</span>,</span><br><span class="line">        <span class="keyword">new</span> <span class="type">BerylliumSphere</span><span class="literal">()</span>, <span class="keyword">new</span> <span class="type">BerylliumSphere</span><span class="literal">()</span></span><br><span class="line">&#125;;</span><br></pre></td></tr></table></figure></p>
<p>动态聚集初始化语法创建数组对象，这种方法可以在任意位置创建和初始化数组对象：(Dynamic aggregate initialization):<br><figure class="highlight ocaml"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br></pre></td><td class="code"><pre><span class="line">a = <span class="keyword">new</span> <span class="type">BerylliumSphere</span><span class="literal">[]</span>&#123;</span><br><span class="line">        <span class="keyword">new</span> <span class="type">BerylliumSphere</span><span class="literal">()</span>, <span class="keyword">new</span> <span class="type">BerylliumSphere</span><span class="literal">()</span>,</span><br><span class="line">&#125;;</span><br></pre></td></tr></table></figure></p>
<h3 id="返回一个数组">返回一个数组</h3><p>C或者C++中不能返回一个数组，而只能返回一个指向数组的指针，这回造成一些问题，使得控制数组的生命周期变得很困难，并且容易造成内存泄露。Java中，只需要直接返回一个数组即可。</p>
<h3 id="多维数组">多维数组</h3><p>使用花括号创建多维数组，每对花括号括起来的集合都会把你带到下一级数组：<br><figure class="highlight mathematica"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br></pre></td><td class="code"><pre><span class="line">int[][] a = <span class="list">&#123; &#123; 1, 2, 3, &#125;</span>, <span class="list">&#123; 4, 5, 6, &#125;</span>, &#125;;</span><br><span class="line">System.out.println(<span class="keyword">Arrays</span>.deepToString(a));</span><br></pre></td></tr></table></figure></p>
<p><strong>使用Arrays.deepToString()将多维数组转换为多个String</strong></p>
<p><strong>粗糙数组：数组中构成矩阵的每个向量都可以具有任意的长度</strong><br><figure class="highlight markdown"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br><span class="line">5</span><br><span class="line">6</span><br><span class="line">7</span><br><span class="line">8</span><br><span class="line">9</span><br></pre></td><td class="code"><pre><span class="line">Random rand = new Random(47);</span><br><span class="line">// 3-D array with varied-length vectors:</span><br><span class="line">int[<span class="link_label"></span>][<span class="link_reference"></span>][<span class="link_label"></span>] a = new int[<span class="link_label">rand.nextInt(7)</span>][<span class="link_reference"></span>][<span class="link_label"></span>];</span><br><span class="line">for(int i = 0; i <span class="xml"><span class="tag">&lt; <span class="attribute">a.length</span>; <span class="attribute">i</span>++) &#123;</span><br><span class="line">    <span class="attribute">a</span>[<span class="attribute">i</span>] = <span class="attribute">new</span> <span class="attribute">int</span>[<span class="attribute">rand.nextInt</span>(<span class="attribute">5</span>)][];</span><br><span class="line">    <span class="attribute">for</span>(<span class="attribute">int</span> <span class="attribute">j</span> = <span class="attribute">0</span>; <span class="attribute">j</span> &lt; <span class="attribute">a</span>[<span class="attribute">i</span>]<span class="attribute">.length</span>; <span class="attribute">j</span>++)</span><br><span class="line">        <span class="attribute">a</span>[<span class="attribute">i</span>][<span class="attribute">j</span>] = <span class="attribute">new</span> <span class="attribute">int</span>[<span class="attribute">rand.nextInt</span>(<span class="attribute">5</span>)];</span><br><span class="line">&#125;</span><br><span class="line"><span class="attribute">System.out.println</span>(<span class="attribute">Arrays.deepToString</span>(<span class="attribute">a</span>));</span></span></span><br></pre></td></tr></table></figure></p>
<p>也可以使用聚集初始化语法创造粗糙数组。自动包装机制对数组初始化器也起作用</p>
<h3 id="数组与泛型">数组与泛型</h3><p><strong>通常，数组与泛型不能很好结合，你不能实例化具有参数化类型的数组。<code>Peel&lt;Banana&gt;[] peels = new Peel&lt;&gt;[10];</code>不合法，擦除会移除参数类型信息，而数组必须知道它们所持有的确切类型，以强制保证类型安全</strong>。</p>
<p><strong>但是它允许你创建对这种数组的引用。你可以创建非泛型的数组，然后将其转型</strong>。<br><figure class="highlight dart"><table><tr><td class="gutter"><pre><span class="line">1</span><br></pre></td><td class="code"><pre><span class="line"><span class="built_in">List</span>&lt;<span class="built_in">String</span>&gt;[] la = (<span class="built_in">List</span>&lt;<span class="built_in">String</span>&gt;[]) <span class="keyword">new</span> ArrayList[<span class="number">10</span>];</span><br></pre></td></tr></table></figure></p>
<p>这样的问题是数组是协变类型的，因此<code>List&lt;String&gt;[]</code>也是一个Object[]，并且利用这点可以把<code>ArrayList&lt;Integer&gt;</code>赋值到数组中，不会有任何编译期或运行时错误。如果知道将来不会向上转型，并且需求也相对比较简单，那么你仍旧可以创建泛型数组。</p>
<p>你也可以参数化数组本身的类型：<br><figure class="highlight actionscript"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br><span class="line">5</span><br><span class="line">6</span><br><span class="line">7</span><br></pre></td><td class="code"><pre><span class="line"><span class="class"><span class="keyword">class</span> <span class="title">ClassParameter</span>&lt;<span class="title">T</span>&gt; </span>&#123;</span><br><span class="line">    <span class="keyword">public</span> T[] f(T[] arg) &#123; <span class="keyword">return</span> arg; &#125;</span><br><span class="line">&#125;</span><br><span class="line"></span><br><span class="line"><span class="class"><span class="keyword">class</span> <span class="title">MethodParameter</span> </span>&#123;</span><br><span class="line">    <span class="keyword">public</span> <span class="keyword">static</span> &lt;T&gt; T[] f(T[] arg) &#123; <span class="keyword">return</span> arg; &#125;</span><br><span class="line">&#125;</span><br></pre></td></tr></table></figure></p>
<p>一般而言，泛型在类或方法的边界处很有效，而在类或方法的内部，擦除会使得泛型变得不适用，例如，你不能创建泛型数组：<br><figure class="highlight smali"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br><span class="line">5</span><br></pre></td><td class="code"><pre><span class="line">// 非法！</span><br><span class="line">//!<span class="instruction"> array </span>=<span class="instruction"> new </span>T<span class="keyword">[</span>size];<span class="instruction"></span><br><span class="line">array </span>=<span class="function"> (</span>T<span class="keyword">[</span>]<span class="function">)</span>new Object<span class="keyword">[</span>size]; // <span class="string">"unchecked"</span> Warning</span><br><span class="line">// 非法！</span><br><span class="line">//!<span class="keyword"> public</span> &lt;T&gt; T<span class="keyword">[</span>]<span class="function"> makeArray(</span><span class="function">)</span> &#123;<span class="instruction"> return </span>new T<span class="keyword">[</span>10]; &#125;</span><br></pre></td></tr></table></figure></p>
<p><strong>由于试图创建的类型已被擦除，所以是类型未知的数组，你可以创建Object数组然后将其转型，但是会得到一个”不受检查”的警告，因为这个数组没有真正持有或动态检查类型T</strong>。</p>
<h3 id="创建测试数据">创建测试数据</h3><h4 id="Arrays-fill()">Arrays.fill()</h4><p><strong>只能用同一个值</strong>（同一个对象引用，因此数组中所有元素都指向同一个对象）填充各个位置，可以填充整个数组或数组的某个区域。</p>
<h4 id="数据生成器">数据生成器</h4><p>为了更灵活的创建更有意义的数组，可以使用数据生成器。<br><figure class="highlight capnproto"><table><tr><td class="gutter"><pre><span class="line">1</span><br></pre></td><td class="code"><pre><span class="line"><span class="class"><span class="keyword">interface</span> <span class="title">Generator</span>&lt;T&gt; </span>&#123; T next(); &#125;</span><br></pre></td></tr></table></figure></p>
<h3 id="Arrays实用功能">Arrays实用功能</h3><p>Arrays类有一套用于数组的静态方法（所有这些方法对各种基本类型和Object类而重载过）：</p>
<table>
<thead>
<tr>
<th>方法</th>
<th>说明</th>
</tr>
</thead>
<tbody>
<tr>
<td>equals()</td>
<td>比较两个数字是否相等</td>
</tr>
<tr>
<td>deepEquals()</td>
<td>用于多维数组比较</td>
</tr>
<tr>
<td>fill()</td>
<td>填充数组</td>
</tr>
<tr>
<td>sort()</td>
<td>数组排序</td>
</tr>
<tr>
<td>binarySearch()</td>
<td>在已经排序的数组中查找元素</td>
</tr>
<tr>
<td>toString</td>
<td>产生数组的String表示</td>
</tr>
<tr>
<td>hashCode()</td>
<td>产生数组的散列码</td>
</tr>
<tr>
<td>asList()</td>
<td>接受任意的序列或数组作为其参数，并转换为List容器</td>
</tr>
</tbody>
</table>
<h4 id="复制数组">复制数组</h4><p><strong>System.arraycopy(): 复制数组，比用for循环复制要快很多，该方法对所有类型做了重载</strong><br><strong>注意复制对象数组的时候，只是浅复制</strong>。另外，System.arraycopy()不会执行自动包装和自动拆包，两个数组必须具有相同的类型。</p>
<h4 id="数组的比较">数组的比较</h4><p>Arrays.equals(): 相等的条件：元素个数相等，对应位置的元素也相等。</p>
<h4 id="数组元素的比较">数组元素的比较</h4><p><strong>程序设计的基本目标是“将保持不变的事物与发生改变的事物相分离”。使用策略设计模式，可以将“会发生变化的代码”封装在单独的类中，你可以将策略对象传递给总是相同的代码，这些代码将使用策略来完成其算法</strong>。</p>
<p>Java有两种方式来提供比较功能。第一种是通过类实现Comparable接口（此接口只有一个compareTo()方法）。<br>第二种是创建实现了Comparator接口的单独的类。这种方法在已有的类并没有实现Comparable接口或实现了该接口但是实现方式不太满意的时候使用。</p>
<p>Collections的reverseOrder方法可以产生一个Comparator，可以反转自然的排序顺序：</p>
<h4 id="数组排序">数组排序</h4><p>使用内置的排序方法，可以对任意的基本类型数组排序，也可以对对象数组排序，只要该对象实现了Comparable接口，或者具有相关联的Comparator<br>Java标准库中的排序算法针对正排序的特殊类型进行了优化： <strong>针对基本类型的快速排序；针对对象设计的“稳定归并排序”</strong>。所以无需担心排序的性能问，除非确实确定了排序不分是程序效率的瓶颈。</p>
<h4 id="在已排序的数组中查找">在已排序的数组中查找</h4><p>如果数组排好序了，可以使用Arrays.binarySearch()进行查找，对未排序的数组使用binarySearch，会产生意想不到的结果。</p>
<ul>
<li>查找到了则返回大于等于0的整数</li>
<li>否则返回负值，表示保持数组排序状态下此目标所应该插入的位置，此负值计算方法： <code>-(插入点) - 1</code></li>
</ul>
<p>如果使用Comparator排序对象数组（基本类型数组无法使用Comparator进行排序）了，使用binarySearch对对象数组进行排序的时候必须提供同样的Comparator</p>
<p>优先容器而不是数组，只有在证明性能成为问题，并且切换到数组对性能有所帮助时，你才应该将程序重构为使用数组。</p>
<h2 id="容器深入研究">容器深入研究</h2><h3 id="完整的容器分类法">完整的容器分类法</h3><p><img src="http://fh-1.qiniudn.com/full_container_taxonomy.png" alt="完整的容器分类法"><br>虚线框表示abstract类，Abstract开头的类是部分实现了特定接口的工具。</p>
<h3 id="填充容器">填充容器</h3><p><strong>static方法<code>Collections.fill()</code>、<code>Collections.nCopies()</code>只复制一个对象引用来填充整个容器，并且只对List对象有用，但是所产生的列表可以传递给构造器或<code>addAll()</code>方法</strong>。</p>
<p><strong><code>Collections.fill()</code>方法只能替换已经在List中存在的元素，而不能添加新的元素</strong>。</p>
<p><code>Object.toString()</code>：该类的名字+该对象的散列码(无符号十六进制表示，通过调用<code>hashCode()</code>生成的)</p>
<h4 id="一种Generator解决方案">一种Generator解决方案</h4><p>所有的Collection子类型都有一个接收另一个Collection对象的构造器，用所接收的Collection对象中的元素来填充新的容器。 </p>
<h4 id="Map生成器">Map生成器</h4><p>可以使用工具来创建任何用于Map或Collection的生成数据集，然后通过构造器或<code>Map.putAll()</code>和<code>Collection.addAll()</code>方法来初始化Map和Collection。</p>
<h4 id="使用Abstract类">使用Abstract类</h4><p>对于产生用于容器的测试数据问题，另一种解决方式是创建定制的Collection和Map实现。每个java.util容器都有其自己的Abstract类，它们提供了该容器的部分实现，因此你必须做的只是去实现那些产生想要的容器所必需的方法。如果所产生的容器是只读的，那么你提供的方法数量将减少到最少。</p>
<p>亨元：在普通的解决方案需要过多的对象，或者产生普通对象太占用空间时使用亨元。亨元模式使得对象的一部分可以被具体化，因此，与对象中的所有事物都包含在对象内部不同，我们可以在更高效的外部表中查找对象的一部分或整体（或者通过其他节省空间的计算来产生对象的一部分或整体）。 </p>
<p>为了创建只读的Map，可以继承AbstractMap并实现<code>entrySet()</code>，为了创建只读的Set，可以继承AbstractSet并实现<code>iterator()</code>和<code>size()</code>。</p>
<p>net/mindview/util/Countries.java代码:<code>FlyweightMap</code>必须实现<code>entrySet()</code>方法，它需要定制的Set实现和定制的<code>Map.Entry</code>类。这里正是亨元部分：每个<code>Map.Entry</code>对象都只存储了它的索引，而不是实际的键和值。当你调用<code>getKey()</code>和<code>getValue()</code>时，它们会使用该索引来返回恰当的DATA元素。EntrySet可以确保它的size不会大于DATA。</p>
<h3 id="Collection的功能方法">Collection的功能方法</h3><p>是Set或List可以执行的操作(List还有额外的功能),Map不是继承自Collection的。</p>
<table>
<thead>
<tr>
<th>方法</th>
<th>描述 </th>
</tr>
</thead>
<tbody>
<tr>
<td><code>boolean add(T)</code></td>
<td>确保容器持有具有泛型类型T的参数。如果没有将此参数添加进容器，则返回false（这是可选的方法）</td>
</tr>
<tr>
<td><code>boolean addAll(Collection&lt;? extends T&gt;)</code></td>
<td>添加参数中所有元素。只要添加了任意元素就返回true（可选）</td>
</tr>
<tr>
<td><code>void clear()</code></td>
<td>移除容器中的所有元素(可选)</td>
</tr>
<tr>
<td><code>boolean contains(T)</code></td>
<td>如果容器中已经持有具有泛型类型T此参数，则返回true</td>
</tr>
<tr>
<td><code>boolean containsAll(Collection&lt;?&gt;)</code></td>
<td>如果容器持有此参数中的所有元素，则返回true</td>
</tr>
<tr>
<td><code>boolean isEmpty()</code></td>
<td>容器中没有元素时返回true。</td>
</tr>
<tr>
<td><code>Iterator&lt;T&gt; iterator()</code></td>
<td>返回一个<code>Iterator&lt;T&gt;</code>，可以用来遍历容器中的所有元素。</td>
</tr>
<tr>
<td><code>boolean remove(Object)</code></td>
<td>如果参数在容器中，则移除此元素的一个实例。如果做了移除动作，则返回true(可选的)</td>
</tr>
<tr>
<td><code>boolean removeAll(Collection&lt;?&gt;)</code></td>
<td>移除参数中的所有元素。只要有移除动作发生就返回true。（可选的）</td>
</tr>
<tr>
<td><code>boolean retainAll(Collection&lt;?&gt;)</code></td>
<td>只保存参数中的元素（应用集合论的“交集”概念）。只要Collection发生了改变就返回true。(可选)</td>
</tr>
<tr>
<td><code>int size()</code></td>
<td>返回容器中元素的数目</td>
</tr>
<tr>
<td><code>Object[] toArray()</code></td>
<td>返回一个数组，该数组包含容器中的所有元素。</td>
</tr>
<tr>
<td><code>&lt;T&gt; T[] toArray(T[] a)</code></td>
<td>返回一个数组，该数组包含容器中的所有元素。返回结果的运行时类型与参数数组a的类型相同，而不是单纯的Object。</td>
</tr>
</tbody>
</table>
<p><strong>请注意，其中不包括随机访问选择元素的get()方法。因为Collection包括Set，而Set是自己维护内部顺序的（这使得随机访问变得没有意义）。因此，如果想检查Collection中的元素，就必须使用迭代器。</strong></p>
<h3 id="可选操作">可选操作</h3><p>执行各种不同的添加和移除的方法在Collection接口中都是可选操作。这意味着实现类并不需要为这些方法提供功能定义。</p>
<p>这是一种不寻常的接口定义方式。接口是面向对象设计中的契约，它声明“无论你选择如何实现该接口，我保证你可以向该接口（描述正式的interface关键字和“任何类或子类支持的方法”）发送这些消息。”但是可选操作违反了这个非常基本的原则，它声明调用这些方法将不会执行有意义的行为，相反，它们会抛出异常。这看起来好像是编译器类型安全被抛弃了。 </p>
<p>事情并不那么糟。如果一个操作是可选的，编译器仍旧会严格要求你只能调用该接口中的方法。这与动态语言不同，动态语言可以在任何对象上调用任何方法，并且可以在运行时发现某个特定调用是否可以工作。</p>
<p><strong>为什么你会将方法定义为可选的呢？那是因为这样做可以防止在设计中出现接口爆炸的情况。“未获支持的操作”这种方式可以实现Java容器类库的一个重要目标：容器应该易学易用。未获支持的操作是一种特例，可以延迟到需要时再实现</strong>。但是，为了让这种方式能够工作：</p>
<ul>
<li>UnsupportedOperationException必须是一种罕见事情。即，对于大多数类来说，所有操作都应该可以工作，只有在特例中才会有未获支持的操作。在Java容器类库中确实如此，因为你在90%的时间里面使用的容器类，如ArrayList、LinkedList、HashSet和HashMap，以及其他的具体实现，都支持所有的操作。这种设计留下了一个“后门”，如果你想创建新的Collection，但是没有为Collection接口中的所有方法都提供有意义的定义，那么它仍旧适合现有的类库。</li>
<li>如果一个操作是未获支持的，那么在实现接口的时候可能就会导致UnsupportedOperationException异常，而不是将产品交给客户以后才出现异常，这种情况是有道理的。毕竟，它表示编程上有错误：使用了不正确的接口实现。</li>
</ul>
<p>值得注意的是，未获支持的操作只有在运行时才能探测到，因此它们表示动态类型检查。如果你以前使用的是像C++这样的静态类型语言，那么可能会觉得Java也只是另一种静态类型语言，但是它还有大量的动态类型机制，因此很难说它到底是哪一种类型的语言。</p>
<h4 id="未获支持的操作">未获支持的操作</h4><p>最常见的未获支持的操作，都来源于背后由固定尺寸的数据结构支持的容器。当你用Arrays.asList()将数组转换为List时，就会得到这样的容器。你还可以通过使用Collection类中“不可修改”的方法，选择创建任何会抛出UnsupportedOperationException的容器（包括Map）。</p>
<p><strong>因为<code>Arrays.asList()</code>会生成一个List，它基于一个固定大小的数组，任何会引起对底层数据结构的尺寸进行修改的方法都会产生一个<code>UnsupportedOperationException</code>异常，以表示对未获支持操作的调用（一个编程错误）</strong>。</p>
<p>注意，应该把<code>Arrays.asList()</code>的结果作为构造器的参数传递给任何Collection（或者使用<code>addAll()</code>方法或<code>Collections.addAll()</code>静态方法），这样可以生成允许使用所有的方法的普通容器。Collections类中的“不可修改”的方法（unmodifiableList()）将容器包装到一个代理中，只要你执行任何视图修改容器的操作，这个代理都会产生<code>UnsupportedOperationException</code>异常。使用这些方法的目标就是产生“常量”容器对象。</p>
<p><strong><code>Arrays.asList()</code>返回固定尺寸的List，而<code>Collections.unmodifiableList()</code>产生不可修改的列表</strong>。</p>
<h3 id="List的功能方法">List的功能方法</h3><p>基本的List使用：调用<code>add()</code>添加对象，使用<code>get()</code>一次取出一个元素，以及调用<code>iterator()</code>获取用于该序列的Iterator。</p>
<h3 id="Set和存储顺序">Set和存储顺序</h3><table>
<thead>
<tr>
<th>类</th>
<th>描述</th>
</tr>
</thead>
<tbody>
<tr>
<td>Set(interface)</td>
<td>存入Set的每个元素都必须是唯一的，因为Set不保存重复元素。加入Set的元素必须定义equals()方法以确保对象唯一性。Set与Collection有完全一样的接口。Set接口不保证维护元素的次序。</td>
</tr>
<tr>
<td>HashSet</td>
<td>如果没有其他的限制，这就应该是你默认的选择，因为它对速度进行了优化，为快速查找而设计的Set。存入HashSet的元素必须定义hashCode()</td>
</tr>
<tr>
<td>TreeSet（SortedSet的唯一实现）</td>
<td>保存次序的Set，底层为树结构。使用它可以从Set中提取有序的序列。元素必须实现Comparable接口</td>
</tr>
<tr>
<td>LinkedHashSet</td>
<td>具有HashSet的查询速度，且内部使用链表维护元素的顺序（插入的次序））。于是在使用迭代器遍历Set时，结果会按元素插入的次序显示。元素也必须定义hashCode()方法</td>
</tr>
</tbody>
</table>
<p>你必须为散列存储和树形存储都创建一个<code>equals()</code>方法，但是<strong><code>hashCode()</code>只有在这个类将会被置于<code>HashSet</code>(这是有可能的，因为它通常是你的Set实现的首先)或者<code>LinkedHashSet</code>中时才是必须的。但是，对于良好的编程风格而言，你应该在覆盖<code>eqauls()</code>方法时，总是同时覆盖<code>hashCode()</code>方法</strong>。</p>
<p><strong>在<code>compareTo()</code>中，我没有使用“简洁明了”的形式<code>return i – i2</code>，因为这是一个常见的编程错误，它只有在i和i2都是无符号的int时才能正确工作。对于Java的有符号int，它就会出错，因为int不够大，不足以表现两个有符号的int的差。例如i是很大的正整数，而j是很大的负整数，<code>i-j</code>就会溢出并且返回负值，这就不正确了</strong>。</p>
<h4 id="SortedSet">SortedSet</h4><p><code>SortedSet</code>中的元素可以保证处于排序状态：<br><code>Comparator comparator()</code> 返回当前Set使用的Comparator；或者返回null，表示以自然方式排序。<br><code>Object first()</code>返回容器中的第一个元素<br><code>Object last()</code>返回容器中的最末一个元素<br><code>SortedSet subSet(fromElement,toElement)</code>生成此Set的子集，范围从fromElement(包含)到toElement(不包含)<br><code>SortedSet headSet(toElement)</code>生成此Set的子集，由小于toElement的元素组成<br><code>SortedSet tailSet(fromElement)</code> 生成此Set的子集，由大于或等于fromElement的元素组成</p>
<h3 id="队列">队列</h3><p>除了并发应用，Queue在Java SE5中仅有的两个实现是<code>LinkedList</code>和<code>PriotityQueue</code>，它们的差异在于排序行为而不是性能。 </p>
<p>除了优先级队列，<code>Queue</code>将精确地按照元素被置于<code>Queue</code>中的顺序产生它们。</p>
<h4 id="双向队列">双向队列</h4><p>可以在任何一端添加或移除元素</p>
<p>在<code>LinkedList</code>中包含支持双向队列的方法，但是在Java标准类库中没有任何显式的用于双向队列的接口。因此<code>LinkedList</code>无法去实现这样的接口，你也无法像在前面的实例中转型到<code>Queue</code>那样去向上转型到<code>Deque</code>。但是，你可以使用组合来创建一个<code>Deque</code>类，并直接从LinkedList中暴露相关的方法。</p>
<h3 id="理解Map">理解Map</h3><h4 id="性能">性能</h4><p>散列码是“相对唯一的”、用以代表对象的int值，它是通过将该对象的某些信息进行转换而生成的。</p>
<table>
<thead>
<tr>
<th>class</th>
<th>description</th>
</tr>
</thead>
<tbody>
<tr>
<td>HashMap(默认选择，速度最快)</td>
<td>Map基于散列表的实现（它取代了Hashtable）。插入和查询“键值对”的开销是固定的。可以通过构造器设置容量和负载因子，以调整容器的性能。</td>
</tr>
<tr>
<td>LinkedHashMap</td>
<td>类似于HashMap，但是迭代遍历它时，取得“键值对”的顺序是其插入次序，或者是最近最少使用(LRU)的次序。只比HashMap慢一点；而在迭代访问时反而更快，因为它使用链表维护内部次序。</td>
</tr>
<tr>
<td>TreeMap</td>
<td>基于红黑树的实现。查看“键”或“键值对”时，它们会被排序（次序由Comparable或Comparator决定）。TreeMap的特点在于，所得到的结果是经过排序的。TreeMap是唯一的带有subMap()方法的Map，它可以访问一个子树。</td>
</tr>
<tr>
<td>WeakHashMap</td>
<td>弱键(weak key)映射，允许释放映射所指向的对象；这是为解决某类特殊问题而设计的。如果映射之外没有引用指向某个“键”，则此“键”可以被垃圾回收器回收</td>
</tr>
<tr>
<td>ConcurrentHashMap</td>
<td>一种线程安全的Map，它不涉及同步加锁。</td>
</tr>
<tr>
<td>IdentityHashMap</td>
<td>使用==代替equals()对“键”进行比较的散列映射。专为解决特殊问题而设计的。</td>
</tr>
</tbody>
</table>
<p>对Map中使用的键的要求与对Set中的元素的要求一样，任何键都必须具有一个<code>equals()</code>方法；如果键被用于散列Map，那么它必须还具有恰当的<code>hashCode()</code>方法；如果键被用于<code>TreeMap</code>，那么它必须实现<code>Comparable</code>。</p>
<h4 id="SortedMap">SortedMap</h4><p>使用<code>SortedMap</code>(<code>TreeMap</code>是其现阶段的唯一实现)，可以确保键处于排序状态。这使得它具有额外的功能。</p>
<p><code>Comparator comparator()</code>：返回当前Map使用的Comparator；或者返回null，表示以自然方式排序。<code>K firstKey()</code>返回Map中的第一个键。<code>K lastKey()</code>返回Map中的最末一个键。<code>SortedMap subMap(K fromKey, K toKey)</code>生成此Map的子集，范围由fromKey（包含）到toKey（不包含）的键确定。<code>SortedMap headMap(K toKey)</code>生成此Map的子集，由键小于toKey的所有键值对组成。<code>SortedMap tailMap(K fromKey)</code>生成此Map的子集，由键大于或等于fromKey的所有键值对组成。</p>
<h4 id="LinkedHashMap">LinkedHashMap</h4><p>为了提高速度，<code>LinkedHashSet</code>散列化所有的元素，但是在遍历键值对时，却又以元素的插入顺序返回键值对。此外，可以在构造器中设定<code>LinkedHashSet</code>，使之采用基于访问的最少使用(LRU)算法，于是没有被访问过的（可被看作需要删除的）元素就会出现在队列的前面。对于需要定期清理元素以节省空间的程序来说，此功能使得程序很容易得以实现。</p>
<h3 id="散列与散列码">散列与散列码</h3><p>标准类库中的类被用作<code>HashMap</code>的键，它用得很好，因为它具备了键所需的全部性质。当你创建用作<code>HashMap</code>的键的类，有可能会忘记在其中放置必需的方法，而这是通常会犯的一个错误。</p>
<h4 id="正确的equals()方法必须满足下列5个条件：">正确的equals()方法必须满足下列5个条件：</h4><ul>
<li>自反性。对任意x，<code>x.equals(x)</code>一定返回true。</li>
<li>对称性。对任意x和y，如果<code>y.equals(x)</code>返回true，则<code>x.equals(y)</code>也返回true。 </li>
<li>传递性。对任意x、y、z，如果<code>x.equals(y)</code>返回true，<code>y.equals(z)</code>返回true，则<code>x.equals(z)</code>一定返回true。</li>
<li>一致性。对任意x和y，如果对象中用于等价比较的信息没有改变，那么无论调用<code>x.equals(y)</code>多少次，返回的结果应该保持一致，要么一直是true，要么一直是false。</li>
<li>对任何不是null的x，<code>x.equals(null)</code>一定返回false。</li>
</ul>
<p>再次强调，默认的<code>Object.equals()</code>只是比较对象的地址，所以一个<code>Groundhog(3)</code>并不等于另一个<code>Groundhog(3)</code>。因此，如果要使用自己的类作为HashMap的键，必须同时重载<code>hashCode()</code>和<code>equals()</code>。</p>
<p><code>hashCode()</code>并不需要总是能够返回唯一的标识码，但是<code>equals()</code>方法必须严格地判断两个对象是否相同。<br><strong><code>instanceof</code>悄悄地检查了此对象是否为<code>null</code>，因为如果<code>instanceof</code>左边的参数为<code>null</code>，它会返回<code>false</code></strong>。</p>
<h4 id="理解hashCode()">理解hashCode()</h4><p>如果不为你的键覆盖<code>hashCode()</code>和<code>equals()</code>，那么使用散列的数据结构（<code>HashSet</code>，<code>HashMap</code>，<code>LinkedHashSet</code>或<code>LinkedHashMap</code>）就无法正确处理你的键。</p>
<p><strong><code>entrySet()</code>的恰当实现应该在Map中提供视图，而不是副本，并且这个视图允许对原始映射表进行修改（副本就不行）</strong>。<br>在MapEntry中的eqauls()方法必须同时检查键和值。</p>
<h4 id="为速度而散列">为速度而散列</h4><p>散列的价值在于速度：散列使得查询得以快速进行。由于瓶颈位于键的查询速度，因此解决方案之一就是保持键的排序状态，然后使用<code>Collections.binarySearch()</code>进行查询。</p>
<p>存储一组元素最快的数据结构是数组，所以使用它来表示键的信息（请小心留意，我是说键的信息，而不是键本身）。数组并不保存键本身。而是通过键对象生成一个数字，将其作为数组的下标。这个数字就是散列码，由定义在Object中的、且可能由你的类覆盖的<code>hashCode()</code>方法（在计算机科学的术语中称为散列函数）生成。</p>
<p><strong>为解决数组容量被固定的问题，不同的键可以产生相同的下标。也就是说，可能会有冲突。因此，数组多大就不重要了，任何键总能在数组中找到它的位置。通常，冲突由外部链接处理：数组并不直接保存值，而是保持值的list。然后对list中的值使用equals()方法进行线性的查询</strong>。这部分的查询自然会比较慢，但是，如果散列函数好的话，数组的每个位置就只有较少的值。因此，不是查询整个list，而是快速地跳到数组的某个位置，只对很少的元素进行比较。这便是HashMap会如此快的原因。</p>
<p>散列表中的槽位通常称为桶位(bucket)。</p>
<p>为使散列分布均匀，桶的数量通常使用质数。事实证明，质数实际上并不是散列桶的理想容量。近来，（经过广泛的测试）Java的散列函数都使用2的整数次方。对现在的处理器来说，除法与求余是最慢的操作。使用2的整数次方长度的散列表，可以用掩码代替除法。因为<code>get()</code>是使用最多的操作，求余数的%操作是其开销最大的部分，而使用2的整数次方可以消除此开销（也可能对hashCode()有些影响）。</p>
<h4 id="覆盖hashCode()">覆盖hashCode()</h4><p>设计<code>hashCode()</code>时最重要的因素就是：无论何时，对同一个对象调用<code>hashCode()</code>都应该生成同样的值。如果在将一个对象用<code>put()</code>添加进HashMap时产生一个<code>hashCode()</code>，而用<code>get()</code>取出时却产生了另一个<code>hashCode()</code>值，那么就无法重新取得该对象了。</p>
<p>此外，也不应该使<code>hashCode()</code>依赖于具有唯一性的对象信息，尤其是使用this的值，这只能产生很糟糕的<code>hashCode()</code>。因为这样做无法生成一个新的键，使之与<code>put()</code>中原始的键值对中的键相同。应该使用对象内有意义的识别信息。</p>
<p>对于String而言，<code>hashCode()</code>明显是基于String的内容的。</p>
<p>因此，要想使<code>hashCode()</code>实用，它必须速度快并且必须有意义。也就是说，它必须基于对象的内容生成散列码。散列码不必是独一无二的（应该更关注生成速度，而不是唯一性），但是通过<code>hashCode()</code>和<code>equals()</code>，必须能够完全确定对象的身份。</p>
<p>因为在生成桶的下标前，<code>hashCode()</code>还需要做进一步的处理，所以散列码的生成范围并不重要，只要是<code>int</code>即可。</p>
<p>还有另外一个影响因素：好的<code>hashCode()</code>应该能够产生分布均匀的散列码。如果散列码都集中在一块，那么<code>HashMap</code>或者<code>HashSet</code>在某些区域的负载会很重，这样就不如分布均匀的散列函数快。</p>
<ul>
<li>给<code>int</code>变量result赋予某个非零常量</li>
<li>为对象内每个有意义的域f(即每个可以做equals()操作的域)计算出一个int散列码e:</li>
</ul>
<table>
<thead>
<tr>
<th>域类型</th>
<th>计算                                                           </th>
</tr>
</thead>
<tbody>
<tr>
<td>boolean</td>
<td><code>c=(f?0:1)</code>                                                    </td>
</tr>
<tr>
<td>byte、char、short或int</td>
<td><code>c=(int)f</code>                                                     </td>
</tr>
<tr>
<td>long</td>
<td><code>c=(int)(f^(f&gt;&gt;&gt;32))</code>                                          </td>
</tr>
<tr>
<td>float</td>
<td><code>c=Float.floatToIntBits(f);</code>                                   </td>
</tr>
<tr>
<td>double</td>
<td><code>long l = Double.doubleToLongBits(f);&lt;br/&gt;c=(int)(l ^ (l&gt;&gt;&gt;32))</code></td>
</tr>
<tr>
<td>Object，其equals()调用这个域的equals()</td>
<td><code>c=f.hashCode()</code>                                               </td>
</tr>
<tr>
<td>数组</td>
<td>对每个元素应用上述规则                                         </td>
</tr>
</tbody>
</table>
<ul>
<li>合并计算得到的散列码：<br>  result = 37*result + c;</li>
<li>返回result。</li>
<li>检查<code>hashCode()</code>最后生成的结果，确保相同的对象有相同的散列码。</li>
</ul>
<p><strong>编写正确的hashCode()和equals()类库</strong><br>Apache的Jakarta Commons项目中有很多工具可以帮助你编写正确的<code>hashCode()</code>和<code>equals()</code>。</p>
<h3 id="选择接口的不同实现">选择接口的不同实现</h3><p>只有四种容器：<code>Map</code>、<code>List</code>、<code>Set</code>和<code>Queue</code>。<code>Hashtable</code>、<code>Vector</code>和<code>Stack</code>的“特征”是，它们是过去遗留下来的类，目的只是为了支持老的程序。（最好不要在新的程序中使用它们）。</p>
<h3 id="性能测试框架">性能测试框架</h3><p>为了防止代码重复以及为了提供测试的一致性，将测试过程的基本功能放置到了一个测试框架中。(模板方法设计模式)</p>
<p>通常System.nanoTime()所产生的值的粒度都会大于1（这个粒度会随机器和操作系统的不同而不同），因此，在结果中可能会存在在某些时间点上的重合。</p>
<h4 id="对List的选择">对List的选择</h4><p><strong>最佳的做法可能是将ArrayList作为默认首选，只有你需要使用额外的功能，或者当程序的性能因为经常从表中间进行插入和删除而变坏的时候，才去选择LinkedList</strong>。如果使用的是固定数量的元素，那么既可以选择使用背后有数组支持的List(就像Arrays.asList产生的列表)，也可以选择真正的数组。<br>CopyOnWriteArrayList是List的一个特殊实现，专门用于并发编程。</p>
<h4 id="微基准测试的危险">微基准测试的危险</h4><p>在编写所谓的微基准测试时，你必须要当心，不能做太多的假设，并且要将你的测试窄化。你还必须仔细地确保你的测试运行足够长的时间，以产生有意义的数据，并且要考虑到某些Java HotSpot技术只有在程序运行了一段时间之后才会踢爆问题（这对于短期运行的程序来说也很重要）。根据计算机和所使用的JVM的不同，所产生的结果也会有所不同。</p>
<p>剖析器可以把性能分析工作做得比你好。Java提供了一个剖析器。</p>
<h4 id="对Set的选择">对Set的选择</h4><p>HashSet的性能基本上总是比TreeSet好，特别是在添加和查询元素时，而这两个操作也是最重要的操作。TreeSet存在的唯一原因是它可以维持元素的排序状态，所以，只有当需要一个排好序的Set时，才应该使用TreeSet。因为其内部结构支持排序，并且因为迭代是我们更有可能执行的操作，所以，用TreeSet迭代通常比用HashSet要快。</p>
<p>注意，对于插入操作，LinkedHashSet比HashSet的代价更高；这是由维护链表所带来额外开销造成的。</p>
<h4 id="对Map的选择">对Map的选择</h4><p>除了IdentityHashMap，所有的Map实现的插入操作都会随着Map尺寸的变大而明显变慢。但是，查找的代价通常比插入要小得多，这是个好消息，因为我们执行查找元素的操作要比执行插入元素的操作多得多。</p>
<p>Hashtable的性能大体上与HashMap相当。因为HashMap是用来代替Hashtable的，因此它们使用了相同的底层存储和查找机制。<br>TreeMap通常比HashMap要慢。与使用TreeSet一样，TreeMap是一种创建有序列表的方式。树的行为是：总是保证有序，并且不必进行特殊的排序。一旦你填充了一个TreeMap，就可以调用keySet()方法来获取键的Set视图，然后调用toArray()来产生由这些键构成的数组。之后，你可以使用静态方法Arrays.binarySearch()在排序数组中快速查找对象。当然，这只有在HashMap的行为不可接受的情况下才有意义，因为HashMap本身就被设计为可以快速查找键。你还可以很方便地通过单个的对象创建操作，或者是调用putAll()，从TreeMap中创建HashMap。最后，当使用Map时，你的第一选择应该是HashMap，只有在你要求Map始终保持有序时，才需要使用TreeMap。<br>LinkedHashMap在插入时比HashMap慢一点，因为它维护了散列数据结构的同时还要维护链表（以保持插入顺序）。这是由于这个列表，使得其迭代速度更快。<br>IdentityHashMap则具有完全不同的性能，因为它使用==而不是equals()来比较元素。</p>
<p><strong>HashMap的性能因子</strong><br>可以通过手工调整HashMap来提高其性能，从而满足我们特定应用的需求。<br>容量：表中的桶位数<br>初始容量：表在创建时所拥有的桶位数。HashMap和HashSet都具有允许你指定初始容量的构造器。<br>尺寸：表中当前存储的项数。<br>负载因子：尺寸/容量。空表的负载因子是0，而半满表的负载因子是0.5，依次类推。负载轻的表产生冲突的可能性小，因此对于插入和查找都是最理想的（但是会减慢使用迭代器进行遍历的过程）。HashMap和HashSet都具有允许你指定负载因子的构造器，表示当负载情况达到该负载因子的水平时，容器将自动增加其容量（桶位数），实现方式是使容量大致加倍，并重新将现有对象分布到新的桶位集中（则被称为再散列）</p>
<p>HashMap使用的默认负载因子是0.75（只有当表达到四分之三满时，才进行再散列），这个因子在时间和空间代价之间达到了平衡。更高的负载因子可以减低表所需的空间，但是会增加查找代价，这很重要，因为查找是我们在大多数时间里所做的操作（包括get()和put()）。<br>如果你知道将在HashMap中存储多少项，那么创建一个具有恰当大小的初始容量将可以避免自动再散列的开销。</p>
<h3 id="实用方法(java-util-Collections)">实用方法(java.util.Collections)</h3><ul>
<li>产生Collection或者Collection的具体子类型的动态类型安全的视图。在不可能使用静态检查版本时使用这些方法。  <figure class="highlight stylus"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br><span class="line">5</span><br><span class="line">6</span><br></pre></td><td class="code"><pre><span class="line"><span class="function"><span class="title">checkedCollection</span><span class="params">(Collection&lt;T&gt;, Class&lt;T&gt; type)</span></span></span><br><span class="line"><span class="function"><span class="title">checkedList</span><span class="params">(List&lt;T&gt;,Class&lt;T&gt; type)</span></span></span><br><span class="line"><span class="function"><span class="title">checkedMap</span><span class="params">(Map&lt;K,V&gt;,Class&lt;K&gt; keyType,Class&lt;V&gt; valueType)</span></span></span><br><span class="line"><span class="function"><span class="title">checkedSet</span><span class="params">(Set&lt;T&gt;,Class&lt;T&gt; type)</span></span></span><br><span class="line"><span class="function"><span class="title">checkedSortedMap</span><span class="params">(SortedMap&lt;K,V&gt;,Class&lt;K&gt; keyType,Class&lt;V&gt; valueType)</span></span></span><br><span class="line"><span class="function"><span class="title">checkedSortedSet</span><span class="params">(SortedSet&lt;T&gt;,Class&lt;T&gt; type)</span></span></span><br></pre></td></tr></table></figure></li>
<li>返回参数Collection中最大或最小的元素——采用Collection内置的自然比较法  <figure class="highlight stylus"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br></pre></td><td class="code"><pre><span class="line"><span class="function"><span class="title">max</span><span class="params">(Collection)</span></span></span><br><span class="line"><span class="function"><span class="title">min</span><span class="params">(Collection)</span></span></span><br></pre></td></tr></table></figure></li>
<li>返回参数Collection中最大或最小的元素——采用Comparator进行比较  <figure class="highlight stylus"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br></pre></td><td class="code"><pre><span class="line"><span class="function"><span class="title">max</span><span class="params">(Collection,Comparator)</span></span></span><br><span class="line"><span class="function"><span class="title">min</span><span class="params">(Collection,Comparator)</span></span></span><br></pre></td></tr></table></figure></li>
<li>返回target在source中第一次出现的位置，或者在找不到时返回-1<br>  <code>indexOfSubList(List source，List target)</code></li>
<li>返回target在source中最后一次出现的位置，或者在找不到时返回-1<br>  <code>lastIndexOfSubList(List source，List target)</code></li>
<li>使用newVal替换所有的oldVal<br>  <code>replaceAll(List&lt;T&gt;,T oldVal,T newVal)</code></li>
<li>逆转所有元素的次序<br>  <code>reverse(List)</code></li>
<li>返回一个Comparator，它可以逆转实现了<code>Comparator&lt;T&gt;</code>的对象集合的自然顺序。第二个版本可以逆转所提供的Comparator的顺序  <figure class="highlight stylus"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br></pre></td><td class="code"><pre><span class="line"><span class="function"><span class="title">reverseOrder</span><span class="params">()</span></span></span><br><span class="line"><span class="function"><span class="title">reverseOrder</span><span class="params">(Comparator&lt;T&gt;)</span></span></span><br></pre></td></tr></table></figure></li>
<li>所有元素向后移动distance个位置，将末尾的元素循环到前面来<br>  <code>rotate(List,int idstance)</code></li>
<li>随机改变指定列表的顺序。第一种形式提供了其自己的随机机制，你可以通过第二种形式提供自己的随机机制  <figure class="highlight stylus"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br></pre></td><td class="code"><pre><span class="line"><span class="function"><span class="title">shuffle</span><span class="params">(List)</span></span></span><br><span class="line"><span class="function"><span class="title">shuffle</span><span class="params">(List,Random)</span></span></span><br></pre></td></tr></table></figure></li>
<li>使用<code>List&lt;T&gt;</code>中的自然顺序排序。第二种形式允许提供用于排序的Comparator  <figure class="highlight stylus"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br></pre></td><td class="code"><pre><span class="line"><span class="function"><span class="title">sort</span><span class="params">(List)</span></span></span><br><span class="line"><span class="function"><span class="title">sort</span><span class="params">(List,Random)</span></span></span><br></pre></td></tr></table></figure></li>
<li>将src中的元素复制到dest<br>  <code>copy(List&lt;? super T&gt; dest,List&lt;? extends T&gt; src)</code></li>
<li>交换list中位置i和位置j的元素。通常比你自己写的代码快。<br>  <code>swap(List,int i,int j)</code></li>
<li>用对象x替换list中的所有元素<br>  <code>fill(List&lt;? super T&gt;,T x)</code></li>
<li>返回大小为n的<code>List&lt;T&gt;</code>,此List不可改变，其中的引用都指向x。<br>  <code>nCopies(int n,T x)</code></li>
<li>当两个集合没有任何相同元素时，返回true<br>  <code>disjoint(Collection,Collection)</code></li>
<li>返回Collection中等于x的元素的个数<br>  <code>frequency(Collection,Object x)</code></li>
<li>返回不可变的空List、Map或Set。这些方法都是泛型的，因此所产生的结果将被参数化为所希望的类型  <figure class="highlight stylus"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br></pre></td><td class="code"><pre><span class="line"><span class="function"><span class="title">emptyList</span><span class="params">()</span></span></span><br><span class="line"><span class="function"><span class="title">emptyMap</span><span class="params">()</span></span></span><br><span class="line"><span class="function"><span class="title">emptySet</span><span class="params">()</span></span></span><br></pre></td></tr></table></figure></li>
<li>产生不可变的<code>Set&lt;T&gt;</code>、<code>List&lt;T&gt;</code>或<code>Map&lt;K,V&gt;</code>,它们都只包含基于所给定参数的内容而形成的单一项。  <figure class="highlight stylus"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br></pre></td><td class="code"><pre><span class="line"><span class="function"><span class="title">singleton</span><span class="params">(T x)</span></span></span><br><span class="line"><span class="function"><span class="title">singletonList</span><span class="params">(T x)</span></span></span><br><span class="line"><span class="function"><span class="title">singletonMap</span><span class="params">(K key,V value)</span></span></span><br></pre></td></tr></table></figure></li>
<li>产生一个<code>ArrayList&lt;T&gt;</code>，它包含的元素的顺序，与（旧式的）Enumeration(Iterator的前身)返回这些元素的顺序相同。用来转换遗留的老代码。<br>  <code>list(Enumeration&lt;T&gt; e)</code></li>
<li>为参数生成一个旧式的<code>enumeration&lt;T&gt;</code><br>  <code>enumeration(Collection&lt;T&gt;)</code></li>
</ul>
<p>注意：min()和max()能作用于Collection对象，所以你无需担心Collection是否应该被排序(只有在执行binarySearch()之前，才确实需要对List或数组进行排序)<br>与使用数组进行查询和排序一样，如果使用Comparator进行排序，那么binarySearch()必须使用相同的Comparator。</p>
<h4 id="设定Collection或Map为不可修改">设定Collection或Map为不可修改</h4><p>对特定类型的“不可修改的”方法的调用并不会产生编译时的检查，但是转换完成后，任何会改变容器内容的操作都会引起UnsupportedOperationException异常。<br>无论哪一种情况，在将容器设为只读之前，必须填入有意义的数据。装载数据后，就应该使用“不可修改的”方法返回的引用去替换掉原本的引用。这样，就不必担心无意中修改了只读的内容。另一方面，此方法允许你保留一份可修改的容器，作为类的private成员，然后通过某个方法调用返回该容器的“只读”的引用。这样一来，就只有你可以修改容器的内容，而别人只能读取。</p>
<h4 id="Collection或Map的同步控制">Collection或Map的同步控制</h4><p>Collections类有办法能够自动同步整个容器。其语法与“不可修改的”方法相似。</p>
<p>快速报错<br>Java容器有一种保护机制，能够防止多个进程同时修改同一个容器的内容。Java容器类类库采用快速报错机制(fail-fast)。它会探查容器上的任何除了你的进程所进行的操作以外的所有变化，一旦它发现其他进程修改了容器，就会立刻抛出ConcurrentModificationException异常。这就是“快速报错”的意思——即，不是使用复制的算法在事后来检查问题。<br>“快速报错”机制的工作原理：只需创建一个迭代器，然后向迭代器所指向的Collection添加点什么</p>
<p>在容器取得迭代器之后，又有东西被放入到了该容器中。当程序的不同部分修改同一个容器时，就可能导致容器的状态不一致，所以，此异常提醒你，应该修改代码。在此例中，应该添加完所有的元素之后，再获取迭代器。</p>
<p>ConcurrentHashMap、CopyOnWriteArrayList、CopyOnWriteArraySet都使用了可以避免ConcurrentModificationException 的技术</p>
<h3 id="持有引用">持有引用</h3><p>java.lang.ref类库包含了一组类，这些类为垃圾回收提供了更大的灵活性。当存在可能会耗尽内存的大对象的时候，这些类显得特别有用。有三个继承自抽象类Reference的类：SoftReferenct、WeakReference和PhantomReference。当垃圾回收器正在考察的对象只能通过某个Reference对象才“可获得”时，上述这些不同的派生类为垃圾回收器提供了不同级别的间接性指示。</p>
<p>对象是可获得的（reachable），是指此对象可在程序中的某处找到。这意味着你在栈中有一个普通的引用，而它正指向此对象；也可能是你的引用指向某个对象，而那个对象含有另一引用指向正在讨论的对象；也可能有更多的中间链接。如果一个对象是“可获得的”，垃圾回收器就不能释放它，因为它仍然为你的程序所用。如果一个对象不是“可获得的”，那么你的程序将无法使用到它，所以将其回收是安全的。</p>
<p>如果想继续持有对某个对象的引用，希望以后还能够访问到该对象，但是也希望能够允许垃圾回收器释放它，这时就应该使用Reference对象。这样，你可以继续使用该对象，而在内存消耗殆尽的时候又允许释放该对象。</p>
<p><strong>以Reference对象作为你和普通引用之间的媒介（代理），另外，一定不能有普通的引用指向那个对象，这样就能达到上述的目的。（普通的引用指没有经Reference对象包装过的引用。）如果垃圾回收器发现某个对象通过普通引用是可获得的，该对象就不会被释放</strong>。</p>
<p><strong>SoftReference、WeakReference和PhantomReference由强到弱排列，对应不同级别的“可获得”。SoftReference用以实现内存敏感的高速缓存。WeakReference是为实现“规范映射”（canonicalizing mapping）而设计的，它不妨碍垃圾回收器回收映射的“键”（或“值”）。“规范映射”中对象的实例可以在程序的多处被同时使用，以节省存储空间。PhantomReference用以调度回收前的清理工作，它比Java终止机制更灵活</strong>。</p>
<p>使用SoftReference和WeakReference时，可以选择是否要将它们放入ReferenceQueue（用作“回收前清理工作”的工具）。而PhantomReference只能依赖于ReferenceQueue。</p>
<h4 id="WeakHashMap">WeakHashMap</h4><p>容器类中有一种特殊的Map，即WeakHashMap，它被用来保存WeakReference。它使得规范映射更易于使用。在这种映射中，每个值只保存一份实例以节省存储空间。当程序需要那个“值”的时候，便在映射中查询现有的对象，然后使用它（而不是重新再创建）。映射可将值作为其初始化中的一部分，不过通常是在需要的时候才生成“值”。</p>
<p>这是一种节约存储空间的技术，因为WeakHashMap允许垃圾回收器自动清理键和值，所以它显得十分便利。对于向WeakHashMap添加键和值的操作，则没有什么特殊要求。映射会自动使用WeakReference包装它们。允许清理元素的触发条件是：不再需要此键了。</p>
<p>运行此程序，会看到垃圾回收器每个三个键就跳过一个，因为那个键的普通引用被存入keys数组，所以那些对象不能被垃圾回收器回收。</p>
<h3 id="Java_1-0/1-1的容器">Java 1.0/1.1的容器</h3><p>避免使用Vector,Enumeration,Hashtable,Stack,BitSet，尽量使用ArrayList,Iterator,HashMap,LinkedList,EnumSet来替代它们。</p>
<h4 id="BitSet">BitSet</h4><p>如果想要高效率地存储大量“开/关”信息，BitSet是很好的选择。不过它的效率仅是对空间而言；如果需要高效的访问时间，BitSet比本地数组稍慢一点。</p>
<p>BitSet的最小容量是long:64位。如果存储的内容比较小，例如8位，那么BitSet就浪费了一些空间。</p>
<p>如果拥有一个可以命名的固定的标志集合，那么EnumSet和BitSet相比，通常是一种更好的选择，因为EnumSet允许你按照名字而不是数字位的位置进行操作，因此可以减少错误。EnumSet还可以防止你因不注意而添加新的标志位置，这种行为能够引发严重的、难以发现的缺陷。你应该使用BitSet而不是EnumSet的理由只包括：只有在运行时才知道需要多少个标志；对标志命名不合理；需要BitSet中的某些特殊操作。</p>

      
    </div>
    <footer class="article-footer">
	  
	  <!-- 百度分享 Start -->
	  <div class="bdsharebuttonbox"><a href="#" class="bds_more" data-cmd="more"></a><a href="#" class="bds_qzone" data-cmd="qzone" title="分享到QQ空间"></a><a href="#" class="bds_tsina" data-cmd="tsina" title="分享到新浪微博"></a><a href="#" class="bds_tqq" data-cmd="tqq" title="分享到腾讯微博"></a><a href="#" class="bds_renren" data-cmd="renren" title="分享到人人网"></a><a href="#" class="bds_weixin" data-cmd="weixin" title="分享到微信"></a></div>
	  <!-- 百度分享 End -->
	  
      
  <ul class="article-tag-list"><li class="article-tag-list-item"><a class="article-tag-list-link" href="/tags/Thinking-in-Java/">Thinking in Java</a></li></ul>

	  
<span>
Updated:<time datetime="2015-04-05T04:22:16.000Z" itemprop="dateModified">2015-04-05</time>
</span>


    </footer>
  </div>
  
    
<nav id="article-nav">
  
    <a href="/2014/11/04/thinking-in-java-note-6/" id="article-nav-newer" class="article-nav-link-wrap">
      <strong class="article-nav-caption">Newer</strong>
      <div class="article-nav-title">
        
          Java编程思想笔记六
        
      </div>
    </a>
  
  
    <a href="/2014/10/17/thinking-in-java-note-4/" id="article-nav-older" class="article-nav-link-wrap">
      <strong class="article-nav-caption">Older</strong>
      <div class="article-nav-title">Java编程思想笔记四</div>
    </a>
  
</nav>

  
</article>



<!-- 多说评论框 start -->

<section id="comments">
  <div class="ds-thread"  data-thread-key="/2014/10/30/thinking-in-java-note-5/" data-title="Java编程思想笔记五" data-url="http://howiefh.github.io/2014/10/30/thinking-in-java-note-5/" id="ds_thread">
    <noscript>Please enable JavaScript to view the <a href="//duoshuo.com/?ref_noscript">comments powered by duoshuo.</a></noscript>
  </div>
</section>

<!-- 多说评论框 end -->
</section>
        
          
  <div id="toc" class="toc-aside">
  <h2 class="toc-title">Contents</h2>
    
        <ol class="toc"><li class="toc-item toc-level-2"><a class="toc-link" href="#数组"><span class="toc-number">1.</span> <span class="toc-text">数组</span></a><ol class="toc-child"><li class="toc-item toc-level-3"><a class="toc-link" href="#数组为什么特殊"><span class="toc-number">1.1.</span> <span class="toc-text">数组为什么特殊</span></a></li><li class="toc-item toc-level-3"><a class="toc-link" href="#数组是第一级对象"><span class="toc-number">1.2.</span> <span class="toc-text">数组是第一级对象</span></a></li><li class="toc-item toc-level-3"><a class="toc-link" href="#返回一个数组"><span class="toc-number">1.3.</span> <span class="toc-text">返回一个数组</span></a></li><li class="toc-item toc-level-3"><a class="toc-link" href="#多维数组"><span class="toc-number">1.4.</span> <span class="toc-text">多维数组</span></a></li><li class="toc-item toc-level-3"><a class="toc-link" href="#数组与泛型"><span class="toc-number">1.5.</span> <span class="toc-text">数组与泛型</span></a></li><li class="toc-item toc-level-3"><a class="toc-link" href="#创建测试数据"><span class="toc-number">1.6.</span> <span class="toc-text">创建测试数据</span></a><ol class="toc-child"><li class="toc-item toc-level-4"><a class="toc-link" href="#Arrays-fill()"><span class="toc-number">1.6.1.</span> <span class="toc-text">Arrays.fill()</span></a></li><li class="toc-item toc-level-4"><a class="toc-link" href="#数据生成器"><span class="toc-number">1.6.2.</span> <span class="toc-text">数据生成器</span></a></li></ol></li><li class="toc-item toc-level-3"><a class="toc-link" href="#Arrays实用功能"><span class="toc-number">1.7.</span> <span class="toc-text">Arrays实用功能</span></a><ol class="toc-child"><li class="toc-item toc-level-4"><a class="toc-link" href="#复制数组"><span class="toc-number">1.7.1.</span> <span class="toc-text">复制数组</span></a></li><li class="toc-item toc-level-4"><a class="toc-link" href="#数组的比较"><span class="toc-number">1.7.2.</span> <span class="toc-text">数组的比较</span></a></li><li class="toc-item toc-level-4"><a class="toc-link" href="#数组元素的比较"><span class="toc-number">1.7.3.</span> <span class="toc-text">数组元素的比较</span></a></li><li class="toc-item toc-level-4"><a class="toc-link" href="#数组排序"><span class="toc-number">1.7.4.</span> <span class="toc-text">数组排序</span></a></li><li class="toc-item toc-level-4"><a class="toc-link" href="#在已排序的数组中查找"><span class="toc-number">1.7.5.</span> <span class="toc-text">在已排序的数组中查找</span></a></li></ol></li></ol></li><li class="toc-item toc-level-2"><a class="toc-link" href="#容器深入研究"><span class="toc-number">2.</span> <span class="toc-text">容器深入研究</span></a><ol class="toc-child"><li class="toc-item toc-level-3"><a class="toc-link" href="#完整的容器分类法"><span class="toc-number">2.1.</span> <span class="toc-text">完整的容器分类法</span></a></li><li class="toc-item toc-level-3"><a class="toc-link" href="#填充容器"><span class="toc-number">2.2.</span> <span class="toc-text">填充容器</span></a><ol class="toc-child"><li class="toc-item toc-level-4"><a class="toc-link" href="#一种Generator解决方案"><span class="toc-number">2.2.1.</span> <span class="toc-text">一种Generator解决方案</span></a></li><li class="toc-item toc-level-4"><a class="toc-link" href="#Map生成器"><span class="toc-number">2.2.2.</span> <span class="toc-text">Map生成器</span></a></li><li class="toc-item toc-level-4"><a class="toc-link" href="#使用Abstract类"><span class="toc-number">2.2.3.</span> <span class="toc-text">使用Abstract类</span></a></li></ol></li><li class="toc-item toc-level-3"><a class="toc-link" href="#Collection的功能方法"><span class="toc-number">2.3.</span> <span class="toc-text">Collection的功能方法</span></a></li><li class="toc-item toc-level-3"><a class="toc-link" href="#可选操作"><span class="toc-number">2.4.</span> <span class="toc-text">可选操作</span></a><ol class="toc-child"><li class="toc-item toc-level-4"><a class="toc-link" href="#未获支持的操作"><span class="toc-number">2.4.1.</span> <span class="toc-text">未获支持的操作</span></a></li></ol></li><li class="toc-item toc-level-3"><a class="toc-link" href="#List的功能方法"><span class="toc-number">2.5.</span> <span class="toc-text">List的功能方法</span></a></li><li class="toc-item toc-level-3"><a class="toc-link" href="#Set和存储顺序"><span class="toc-number">2.6.</span> <span class="toc-text">Set和存储顺序</span></a><ol class="toc-child"><li class="toc-item toc-level-4"><a class="toc-link" href="#SortedSet"><span class="toc-number">2.6.1.</span> <span class="toc-text">SortedSet</span></a></li></ol></li><li class="toc-item toc-level-3"><a class="toc-link" href="#队列"><span class="toc-number">2.7.</span> <span class="toc-text">队列</span></a><ol class="toc-child"><li class="toc-item toc-level-4"><a class="toc-link" href="#双向队列"><span class="toc-number">2.7.1.</span> <span class="toc-text">双向队列</span></a></li></ol></li><li class="toc-item toc-level-3"><a class="toc-link" href="#理解Map"><span class="toc-number">2.8.</span> <span class="toc-text">理解Map</span></a><ol class="toc-child"><li class="toc-item toc-level-4"><a class="toc-link" href="#性能"><span class="toc-number">2.8.1.</span> <span class="toc-text">性能</span></a></li><li class="toc-item toc-level-4"><a class="toc-link" href="#SortedMap"><span class="toc-number">2.8.2.</span> <span class="toc-text">SortedMap</span></a></li><li class="toc-item toc-level-4"><a class="toc-link" href="#LinkedHashMap"><span class="toc-number">2.8.3.</span> <span class="toc-text">LinkedHashMap</span></a></li></ol></li><li class="toc-item toc-level-3"><a class="toc-link" href="#散列与散列码"><span class="toc-number">2.9.</span> <span class="toc-text">散列与散列码</span></a><ol class="toc-child"><li class="toc-item toc-level-4"><a class="toc-link" href="#正确的equals()方法必须满足下列5个条件："><span class="toc-number">2.9.1.</span> <span class="toc-text">正确的equals()方法必须满足下列5个条件：</span></a></li><li class="toc-item toc-level-4"><a class="toc-link" href="#理解hashCode()"><span class="toc-number">2.9.2.</span> <span class="toc-text">理解hashCode()</span></a></li><li class="toc-item toc-level-4"><a class="toc-link" href="#为速度而散列"><span class="toc-number">2.9.3.</span> <span class="toc-text">为速度而散列</span></a></li><li class="toc-item toc-level-4"><a class="toc-link" href="#覆盖hashCode()"><span class="toc-number">2.9.4.</span> <span class="toc-text">覆盖hashCode()</span></a></li></ol></li><li class="toc-item toc-level-3"><a class="toc-link" href="#选择接口的不同实现"><span class="toc-number">2.10.</span> <span class="toc-text">选择接口的不同实现</span></a></li><li class="toc-item toc-level-3"><a class="toc-link" href="#性能测试框架"><span class="toc-number">2.11.</span> <span class="toc-text">性能测试框架</span></a><ol class="toc-child"><li class="toc-item toc-level-4"><a class="toc-link" href="#对List的选择"><span class="toc-number">2.11.1.</span> <span class="toc-text">对List的选择</span></a></li><li class="toc-item toc-level-4"><a class="toc-link" href="#微基准测试的危险"><span class="toc-number">2.11.2.</span> <span class="toc-text">微基准测试的危险</span></a></li><li class="toc-item toc-level-4"><a class="toc-link" href="#对Set的选择"><span class="toc-number">2.11.3.</span> <span class="toc-text">对Set的选择</span></a></li><li class="toc-item toc-level-4"><a class="toc-link" href="#对Map的选择"><span class="toc-number">2.11.4.</span> <span class="toc-text">对Map的选择</span></a></li></ol></li><li class="toc-item toc-level-3"><a class="toc-link" href="#实用方法(java-util-Collections)"><span class="toc-number">2.12.</span> <span class="toc-text">实用方法(java.util.Collections)</span></a><ol class="toc-child"><li class="toc-item toc-level-4"><a class="toc-link" href="#设定Collection或Map为不可修改"><span class="toc-number">2.12.1.</span> <span class="toc-text">设定Collection或Map为不可修改</span></a></li><li class="toc-item toc-level-4"><a class="toc-link" href="#Collection或Map的同步控制"><span class="toc-number">2.12.2.</span> <span class="toc-text">Collection或Map的同步控制</span></a></li></ol></li><li class="toc-item toc-level-3"><a class="toc-link" href="#持有引用"><span class="toc-number">2.13.</span> <span class="toc-text">持有引用</span></a><ol class="toc-child"><li class="toc-item toc-level-4"><a class="toc-link" href="#WeakHashMap"><span class="toc-number">2.13.1.</span> <span class="toc-text">WeakHashMap</span></a></li></ol></li><li class="toc-item toc-level-3"><a class="toc-link" href="#Java_1-0/1-1的容器"><span class="toc-number">2.14.</span> <span class="toc-text">Java 1.0/1.1的容器</span></a><ol class="toc-child"><li class="toc-item toc-level-4"><a class="toc-link" href="#BitSet"><span class="toc-number">2.14.1.</span> <span class="toc-text">BitSet</span></a></li></ol></li></ol></li></ol>
    
  </div>

<aside id="sidebar">

  
    
<div class="widget-wrap">
  <h3 class="widget-title">ABOUT ME</h3>
  <ul class="widget about-me">
    
    <li><img class="author" title="About me" src="http://fh-1.qiniudn.com/okal-eltocat.jpg" /></li>
    
    
    <li>Hi,I'm FengHao.</li>
    
    <li>I'll share something interesting and my learning experience with you at this blog.</li>
    
    <li>前博客:<a href="http://hi.baidu.com/idea_star" target="_BLANK">百度空间</a></li>
    
  </ul>
</div>


  
    
  <div class="widget-wrap">
    <h3 class="widget-title">Categories</h3>
    <div class="widget">
      <ul class="category-list"><li class="category-list-item"><a class="category-list-link" href="/categories/Android/">Android</a><span class="category-list-count">3</span></li><li class="category-list-item"><a class="category-list-link" href="/categories/C/">C</a><span class="category-list-count">2</span></li><li class="category-list-item"><a class="category-list-link" href="/categories/Database/">Database</a><span class="category-list-count">13</span><ul class="category-list-child"><li class="category-list-item"><a class="category-list-link" href="/categories/Database/MongoDB/">MongoDB</a><span class="category-list-count">10</span></li><li class="category-list-item"><a class="category-list-link" href="/categories/Database/MySQL/">MySQL</a><span class="category-list-count">2</span></li></ul></li><li class="category-list-item"><a class="category-list-link" href="/categories/Eclipse/">Eclipse</a><span class="category-list-count">1</span></li><li class="category-list-item"><a class="category-list-link" href="/categories/FTP/">FTP</a><span class="category-list-count">2</span></li><li class="category-list-item"><a class="category-list-link" href="/categories/Git/">Git</a><span class="category-list-count">3</span></li><li class="category-list-item"><a class="category-list-link" href="/categories/Hexo/">Hexo</a><span class="category-list-count">3</span></li><li class="category-list-item"><a class="category-list-link" href="/categories/Java/">Java</a><span class="category-list-count">20</span><ul class="category-list-child"><li class="category-list-item"><a class="category-list-link" href="/categories/Java/FreeMarker/">FreeMarker</a><span class="category-list-count">3</span></li><li class="category-list-item"><a class="category-list-link" href="/categories/Java/Shiro/">Shiro</a><span class="category-list-count">2</span></li></ul></li><li class="category-list-item"><a class="category-list-link" href="/categories/JavaEE/">JavaEE</a><span class="category-list-count">4</span><ul class="category-list-child"><li class="category-list-item"><a class="category-list-link" href="/categories/JavaEE/Hibernate/">Hibernate</a><span class="category-list-count">1</span></li><li class="category-list-item"><a class="category-list-link" href="/categories/JavaEE/JSP/">JSP</a><span class="category-list-count">1</span></li><li class="category-list-item"><a class="category-list-link" href="/categories/JavaEE/Spring/">Spring</a><span class="category-list-count">2</span></li></ul></li><li class="category-list-item"><a class="category-list-link" href="/categories/JavaScript/">JavaScript</a><span class="category-list-count">5</span><ul class="category-list-child"><li class="category-list-item"><a class="category-list-link" href="/categories/JavaScript/jQuery/">jQuery</a><span class="category-list-count">1</span></li></ul></li><li class="category-list-item"><a class="category-list-link" href="/categories/Linux/">Linux</a><span class="category-list-count">2</span></li><li class="category-list-item"><a class="category-list-link" href="/categories/PHP/">PHP</a><span class="category-list-count">5</span></li><li class="category-list-item"><a class="category-list-link" href="/categories/Suse/">Suse</a><span class="category-list-count">1</span></li><li class="category-list-item"><a class="category-list-link" href="/categories/Ubuntu/">Ubuntu</a><span class="category-list-count">5</span></li><li class="category-list-item"><a class="category-list-link" href="/categories/Vim/">Vim</a><span class="category-list-count">8</span></li><li class="category-list-item"><a class="category-list-link" href="/categories/编程/">编程</a><span class="category-list-count">2</span></li><li class="category-list-item"><a class="category-list-link" href="/categories/软件/">软件</a><span class="category-list-count">1</span></li></ul>
    </div>
  </div>


  
    
  <div class="widget-wrap">
    <h3 class="widget-title">Tag Cloud</h3>
    <div class="widget tagcloud">
      <a href="/tags/Android/" style="font-size: 14.75px; color: #65bfa7">Android</a> <a href="/tags/C/" style="font-size: 13.88px; color: #71c1c2">C</a> <a href="/tags/CAS/" style="font-size: 13px; color: #7dc3de">CAS</a> <a href="/tags/Chrome/" style="font-size: 13px; color: #7dc3de">Chrome</a> <a href="/tags/Clean-Code/" style="font-size: 13.88px; color: #71c1c2">Clean Code</a> <a href="/tags/Database/" style="font-size: 13px; color: #7dc3de">Database</a> <a href="/tags/Eclipse/" style="font-size: 13px; color: #7dc3de">Eclipse</a> <a href="/tags/FTP/" style="font-size: 13.88px; color: #71c1c2">FTP</a> <a href="/tags/FreeMarker/" style="font-size: 14.75px; color: #65bfa7">FreeMarker</a> <a href="/tags/Gcc/" style="font-size: 13px; color: #7dc3de">Gcc</a> <a href="/tags/Git/" style="font-size: 14.75px; color: #65bfa7">Git</a> <a href="/tags/Github-Pages/" style="font-size: 13px; color: #7dc3de">Github Pages</a> <a href="/tags/Hexo/" style="font-size: 14.75px; color: #65bfa7">Hexo</a> <a href="/tags/Hibernate/" style="font-size: 13px; color: #7dc3de">Hibernate</a> <a href="/tags/JSP/" style="font-size: 13px; color: #7dc3de">JSP</a> <a href="/tags/JVM/" style="font-size: 14.75px; color: #65bfa7">JVM</a> <a href="/tags/Java/" style="font-size: 14.75px; color: #65bfa7">Java</a> <a href="/tags/JavaMail/" style="font-size: 13px; color: #7dc3de">JavaMail</a> <a href="/tags/JavaScript/" style="font-size: 16.5px; color: #4dbc6f">JavaScript</a> <a href="/tags/Linux/" style="font-size: 13.88px; color: #71c1c2">Linux</a> <a href="/tags/Log/" style="font-size: 13px; color: #7dc3de">Log</a> <a href="/tags/Markdown/" style="font-size: 13.88px; color: #71c1c2">Markdown</a> <a href="/tags/MongoDB/" style="font-size: 20px; color: #1db400">MongoDB</a> <a href="/tags/MySQL/" style="font-size: 13.88px; color: #71c1c2">MySQL</a> <a href="/tags/PHP/" style="font-size: 16.5px; color: #4dbc6f">PHP</a> <a href="/tags/Rhythmbox/" style="font-size: 13px; color: #7dc3de">Rhythmbox</a> <a href="/tags/SSO/" style="font-size: 13px; color: #7dc3de">SSO</a> <a href="/tags/Servlet/" style="font-size: 13px; color: #7dc3de">Servlet</a> <a href="/tags/Shiro/" style="font-size: 13.88px; color: #71c1c2">Shiro</a> <a href="/tags/Spring/" style="font-size: 13.88px; color: #71c1c2">Spring</a> <a href="/tags/Suse/" style="font-size: 13px; color: #7dc3de">Suse</a> <a href="/tags/Thinking-in-Java/" style="font-size: 19.13px; color: #29b61c">Thinking in Java</a> <a href="/tags/Ubuntu/" style="font-size: 17.38px; color: #41ba53">Ubuntu</a> <a href="/tags/Vim/" style="font-size: 18.25px; color: #35b838">Vim</a> <a href="/tags/VirtualBox/" style="font-size: 13px; color: #7dc3de">VirtualBox</a> <a href="/tags/Vsftpd/" style="font-size: 13px; color: #7dc3de">Vsftpd</a> <a href="/tags/jQuery/" style="font-size: 13px; color: #7dc3de">jQuery</a> <a href="/tags/pam-mysql/" style="font-size: 13px; color: #7dc3de">pam_mysql</a> <a href="/tags/小米/" style="font-size: 13px; color: #7dc3de">小米</a> <a href="/tags/软件/" style="font-size: 15.63px; color: #59bd8b">软件</a>
    </div>
  </div>


  
    
  <div class="widget-wrap">
    <h3 class="widget-title">Archives</h3>
    <div class="widget">
      <ul class="archive-list"><li class="archive-list-item"><a class="archive-list-link" href="/archives/2015/09/">September 2015</a><span class="archive-list-count">1</span></li><li class="archive-list-item"><a class="archive-list-link" href="/archives/2015/08/">August 2015</a><span class="archive-list-count">4</span></li><li class="archive-list-item"><a class="archive-list-link" href="/archives/2015/07/">July 2015</a><span class="archive-list-count">1</span></li><li class="archive-list-item"><a class="archive-list-link" href="/archives/2015/05/">May 2015</a><span class="archive-list-count">5</span></li><li class="archive-list-item"><a class="archive-list-link" href="/archives/2015/04/">April 2015</a><span class="archive-list-count">4</span></li><li class="archive-list-item"><a class="archive-list-link" href="/archives/2015/03/">March 2015</a><span class="archive-list-count">4</span></li><li class="archive-list-item"><a class="archive-list-link" href="/archives/2015/02/">February 2015</a><span class="archive-list-count">2</span></li><li class="archive-list-item"><a class="archive-list-link" href="/archives/2014/12/">December 2014</a><span class="archive-list-count">2</span></li><li class="archive-list-item"><a class="archive-list-link" href="/archives/2014/11/">November 2014</a><span class="archive-list-count">2</span></li><li class="archive-list-item"><a class="archive-list-link" href="/archives/2014/10/">October 2014</a><span class="archive-list-count">4</span></li><li class="archive-list-item"><a class="archive-list-link" href="/archives/2014/09/">September 2014</a><span class="archive-list-count">2</span></li><li class="archive-list-item"><a class="archive-list-link" href="/archives/2014/08/">August 2014</a><span class="archive-list-count">1</span></li><li class="archive-list-item"><a class="archive-list-link" href="/archives/2014/07/">July 2014</a><span class="archive-list-count">1</span></li><li class="archive-list-item"><a class="archive-list-link" href="/archives/2014/06/">June 2014</a><span class="archive-list-count">6</span></li><li class="archive-list-item"><a class="archive-list-link" href="/archives/2014/05/">May 2014</a><span class="archive-list-count">4</span></li><li class="archive-list-item"><a class="archive-list-link" href="/archives/2014/04/">April 2014</a><span class="archive-list-count">4</span></li><li class="archive-list-item"><a class="archive-list-link" href="/archives/2014/03/">March 2014</a><span class="archive-list-count">3</span></li><li class="archive-list-item"><a class="archive-list-link" href="/archives/2014/02/">February 2014</a><span class="archive-list-count">11</span></li><li class="archive-list-item"><a class="archive-list-link" href="/archives/2014/01/">January 2014</a><span class="archive-list-count">1</span></li><li class="archive-list-item"><a class="archive-list-link" href="/archives/2013/12/">December 2013</a><span class="archive-list-count">1</span></li><li class="archive-list-item"><a class="archive-list-link" href="/archives/2013/11/">November 2013</a><span class="archive-list-count">2</span></li><li class="archive-list-item"><a class="archive-list-link" href="/archives/2013/08/">August 2013</a><span class="archive-list-count">3</span></li><li class="archive-list-item"><a class="archive-list-link" href="/archives/2013/07/">July 2013</a><span class="archive-list-count">2</span></li><li class="archive-list-item"><a class="archive-list-link" href="/archives/2013/06/">June 2013</a><span class="archive-list-count">1</span></li><li class="archive-list-item"><a class="archive-list-link" href="/archives/2013/05/">May 2013</a><span class="archive-list-count">5</span></li><li class="archive-list-item"><a class="archive-list-link" href="/archives/2013/04/">April 2013</a><span class="archive-list-count">3</span></li><li class="archive-list-item"><a class="archive-list-link" href="/archives/2012/03/">March 2012</a><span class="archive-list-count">1</span></li></ul>
    </div>
  </div>


  
    <div class="widget-wrap">
  <h3 class="widget-title">Calendar</h3>
  <div class="widget">
    <div id="g-calendar" class="g-calendar">
        <span class="g-calendar-prev"></span>
		 
        <span class="g-calendar-back"></span>
        <span class="g-calendar-now"></span>
		 
        <span class="g-calendar-next"></span>
        <div class="g-calendar-hd"></div>
        <div class="g-calendar-tit"></div>
        <div class="g-calendar-bd"></div>
    </div>
  </div>
</div>
<script type="text/javascript">
function LGY_calendar(wrapId, options){
    this.oWrap = this.getId(wrapId);
    this.oHead = this.getByClassName('g-calendar-hd',this.oWrap)[0];
    this.oBody = this.getByClassName('g-calendar-bd',this.oWrap)[0];
    this.oTit = this.getByClassName('g-calendar-tit',this.oWrap)[0];
    this.oPrev = this.getByClassName('g-calendar-prev',this.oWrap)[0];
    this.oNext = this.getByClassName('g-calendar-next',this.oWrap)[0];
    this.oNow = this.getByClassName('g-calendar-now',this.oWrap)[0];
    this.oBack = this.getByClassName('g-calendar-back',this.oWrap)[0];
    this.init();
}
LGY_calendar.prototype = {
    ///////////获取ID元素
    getId:function(id){
        return document.getElementById(id);
    },
    ////////获取css类名元素
    getByClassName:function(className,parent){
        var elem = [],
            node = parent != undefined&&parent.nodeType==1?parent.getElementsByTagName('*'):document.getElementsByTagName('*'),
            p = new RegExp("(^|\\s)"+className+"(\\s|$)");
        for(var n=0,i=node.length;n<i;n++){
            if(p.test(node[n].className)){
                elem.push(node[n]);
            }
        }
        return elem;
    },
    //填充日历
    fillDate:function(year,month){
        //本月份第一天是星期几-为显示上个月的天数做铺垫
        var first_day = new Date(year,month,1).getDay(),
        //如果刚好是星期天，则空出一行（显示上个月的天数）
            first_day = first_day == 0?first_day=7:first_day;
        //本月份最后一天是几号
        var final_date = new Date(year,month+1,0).getDate(),
        //上个月的最后一天是几号
            last_date = new Date(year,month,0).getDate(),
        //剩余的格子数--即排在末尾的格子数
            surplus = 42 - first_day - final_date;
        //设置年的链接
        var yearHead = "<a href='/" + "archives/" + year + "/'>" + year + " "+ "</a>"; 
        //设置年的链接
        var monthHead = "";
        var month1 = month + 1;
        if (month1 < 10) {
            monthHead = "<a href='/" + "archives/" + year + "/" + "0" + month1 + "/'>" + " " + month1 + " " + "</a>";
        } else {
            monthHead = "<a href='/" + "archives/" + year + "/" + month1 + "/'>" + " " + month1 + " " + "</a>";
        }
        //设置表头的日历
        this.oHead.innerHTML = yearHead+'年'+monthHead+'月';
        //填充日历执行
        var html = '';
        //上个月的显示天数
        for(var i=0;i<first_day;i++){
            html+='<span class="g-calendar-grey">'+(last_date-(first_day-1)+i)+'</span>';
        }
        //本月的显示天数
        var postdate = new Date("Thu Oct 30 2014 11:54:53 GMT+0800"); 
        if (true && postdate.getFullYear() == year && postdate.getMonth() == month) { 
            html += '<span>1</span><span>2</span><span>3</span><span>4</span><span>5</span><span>6</span><span>7</span><span>8</span><span>9</span><span>10</span><span><a href="/2014/10/11/git-encoding/" title="解决git在Windows下的乱码问题">11</a></span><span>12</span><span><a href="/2014/10/13/setting-up-git-server/" title="搭建git服务器">13</a></span><span>14</span><span>15</span><span>16</span><span><a href="/2014/10/17/thinking-in-java-note-4/" title="Java编程思想笔记四">17</a></span><span>18</span><span>19</span><span>20</span><span>21</span><span>22</span><span>23</span><span>24</span><span>25</span><span>26</span><span>27</span><span>28</span><span>29</span><span><a href="/2014/10/30/thinking-in-java-note-5/" title="Java编程思想笔记五">30</a></span>';
        } else {
            for(var j=0;j<final_date;j++){        
                html+='<span id="d'+(j+1)+'">'+(j+1)+'</span>';
            }
        }
        //下个月的显示天数
        for(var k=0;k<surplus;k++){
            html+='<span class="g-calendar-grey">'+(k+1)+'</span>';
        }
        //fill
        this.oBody.innerHTML = html;
        // 当前状态
        if(year==this.c_year&&this.c_month==month){
            this.oBody.getElementsByTagName('span')[first_day+this.date-1].className='g-calendar-on';
        }

        // 对所有文章遍历,然后将有文章的日期加上链接,如果文章太多的话,生成页面会很大,去掉了
        
    },
    // next切换
    next:function(){
        var _that = this;
        this.oNext.onclick = function(){
            _that.month++;
            if(_that.month>11){
                _that.month = 0;
                _that.year++;
            }
            // 填充日历
            _that.fillDate(_that.year,_that.month);
        };
    },
    // back 切换
    back:function(){
        var _that = this;
        if(this.oBack != undefined) {
            this.oBack.onclick = function(){
                var postdate = new Date("Thu Oct 30 2014 11:54:53 GMT+0800"); 
                _that.year = postdate.getFullYear();
                _that.month = postdate.getMonth();
                // 填充日历
                _that.fillDate(_that.year,_that.month);
            };
        }
    },
    // now切换
    now:function(){
        var _that = this;
        if(this.oNow != undefined ) {
            this.oNow.onclick = function(){
                var nowDate = new Date(); 
                _that.year = nowDate.getFullYear();
                _that.month = nowDate.getMonth();
                // 填充日历
                _that.fillDate(_that.year,_that.month);
            };
        }
    },
    // prev切换
    prev:function(){
        var _that = this;
        this.oPrev.onclick = function(){
            _that.month--;
            if(_that.month<0){
                _that.month = 11;
                _that.year--;
            }
            // 填充日历
            _that.fillDate(_that.year,_that.month);
        };
    },
    init:function(){
        this.oTit.innerHTML = '<span>日</span><span>一</span><span>二</span><span>三</span><span>四</span><span>五</span><span>六</span>';
        // 获取今天的日历时间
        var now = new Date();
        this.c_year = this.year = now.getFullYear();
        this.c_month = this.month = now.getMonth();
        this.date = now.getDate();
        // 初始化--填充日历
        this.fillDate(this.year,this.month);
        //next切换
        this.next();
        //prev切换
        this.prev();
        //back 切换
        this.back();
        //now 切换
        this.now();
    }
}
new LGY_calendar('g-calendar');
</script>

  
    
  <div class="widget-wrap">
    <h3 class="widget-title">Recent Posts</h3>
    <div class="widget">
      <ul>
        
          <li>
            <a href="/2015/09/01/javascript-summary/">JavaScript 总结</a>
          </li>
        
          <li>
            <a href="/2015/08/28/javascript-oop-function-expression-and-async/">JavaScript 面向对象程序设计、函数表达式和异步编程</a>
          </li>
        
          <li>
            <a href="/2015/08/28/javascript-reference-type/">JavaScript 引用类型</a>
          </li>
        
          <li>
            <a href="/2015/08/28/javascript-grammar/">JavaScript 基本语法</a>
          </li>
        
          <li>
            <a href="/2015/08/10/java-web/">Java Web 笔记</a>
          </li>
        
      </ul>
    </div>
  </div>


  
    
<div class="widget-wrap">
  <h3 class="widget-title">Recent Comments</h3>
  <ul class="widget ds-recent-comments" data-num-items="5" data-show-avatars="0" data-show-title="1" data-show-time="1"></ul>
</div>
<!-- 需要多说的公用代码 -->


  

</aside>

        
      </div>
      <footer id="footer">
  
  <div class="outer">
    <div id="footer-info" class="inner">
      &copy; 2015 howiefh<br>
      Powered by <a href="http://zespia.tw/hexo/" target="_blank">Hexo</a> and Theme by <a href="https://github.com/howiefh/hexo-theme-landscape-f" target="_blank" title="Landscape-F">Landscape-F</a>
    </div>
  </div>
</footer>

    </div>
    <nav id="mobile-nav">
  
    <a href="/" class="mobile-nav-link">Home</a>
  
    <a href="/archives" class="mobile-nav-link">Archives</a>
  
</nav>
    

<!-- 多说公共JS代码 start (一个网页只需插入一次) -->

<script type="text/javascript">
  var duoshuoQuery = {short_name:"howiefh"};
  (function() {
	var ds = document.createElement('script');
	ds.type = 'text/javascript';ds.async = true;
	ds.src = (document.location.protocol == 'https:' ? 'https:' : 'http:') + '//static.duoshuo.com/embed.js';
	ds.charset = 'UTF-8';
	(document.getElementsByTagName('head')[0] 
		|| document.getElementsByTagName('body')[0]).appendChild(ds);
  })();
</script> 

<!-- 多说公共JS代码 end -->

<!-- 百度分享 start -->

<script>window._bd_share_config={"common":{"bdSnsKey":{},"bdText":"","bdMini":"2","bdMiniList":["mshare","douban","bdysc","sqq","qq","hi","baidu","huaban","youdao","sdo","mail","xg","diandian","fx","copy","print"],"bdPic":"","bdStyle":"1","bdSize":"16"},"share":{},"image":{"viewList":["qzone","tsina","tqq","renren","weixin"],"viewText":"分享到：","viewSize":"16"}};with(document)0[(getElementsByTagName('head')[0]||body).appendChild(createElement('script')).src='http://bdimg.share.baidu.com/static/api/js/share.js?v=89860593.js?cdnversion='+~(-new Date()/36e5)];</script>

<!-- 百度分享 end -->

<!--
<script src="//ajax.googleapis.com/ajax/libs/jquery/2.0.3/jquery.min.js"></script>
<script src="/js/jquery.min.js"></script>
-->
<script src="/js/jquery.min.js" type="text/javascript"></script>


  <link rel="stylesheet" href="/fancybox/jquery.fancybox.css" type="text/css">
  <script src="/fancybox/jquery.fancybox.pack.js" type="text/javascript"></script>


<div class="bottom-btn">

	<a class="icon-gotop" href="javascript:void(0)" title="返回顶部"></a>
	<script src="/js/gotop.js" type="text/javascript"></script>
	<!--
	<script src="/js/gotop.js"></script>
	-->


	<a class="icon-toc-toggle" href="javascript:void(0)" title="文章目录"></a>
	<!--
	<script src="/js/toc_aside_toggle.js"></script>
	-->

</div>
<script src="/js/toc_aside_toggle.js" type="text/javascript"></script>


<script src="/js/script.js" type="text/javascript"></script>

  </div>
</body>
</html>
